C / C++ / MFC

17-Jun-10 9:22

what do I need as an overload= for the array type

I have a vector template that needs an overload

http://www.contract-developer.tk

Stephen Hewitt17-Jun-10 14:01

17-Jun-10 14:01

Perhaps this well set you on the right path:

// Console.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <tchar.h>
#include <iostream>

using namespace std;

class MyVector
{
public:
	template <typename T, size_t N>
	MyVector& operator=(const T(&a)[N])
	{
		for (size_t i=0; i<N; ++i)
		{
			cout << a[i] << " ";
		}
	
		cout << endl;

		return *this;
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	MyVector vec;
	int n[] = {1, 2, 3, 4};
	const char* s[] = {"One", "Two", "Three", "Four"};
	vec = n;
	vec = s;

	cout << endl;
}

Output:

1 2 3 4
One Two Three Four

NOTE: Visual Studio 6 can't handle it.

Steve

VeganFanatic17-Jun-10 14:03

17-Jun-10 14:03

For some reason VS 2010 does not like that.

Do I need more assignment overloading?

vector operator= (vector &that) {           // assignment operator<br />
    for (int i=0; i < that.data.size(); i++)<br />
        this->data[i] = that.data[i];<br />
    return *this;<br />
}<br />
vector operator= (base* that) {         // assignment operator<br />
    for (int i=0; i < sizeof(that); i++)<br />
        this->data[i] = that[i];<br />
    return *this;<br />
}<br />

http://www.contract-developer.tk

Stephen Hewitt17-Jun-10 14:18

Re: array => vector [modified]

17-Jun-10 14:18

It looks like you need something like this instead of the second overload:

template <std::size_t N>
vector& operator=(const base(&that)[N])
{
	for (int i=0; i<N; ++i)
		data[i] = that[i];
	return *this;
}

sizeof(that) is wrong for may reasons. It's the size of a single base type in bytes. Also, read up on array to pointer decay.

NOTE: Both overload should return vector&, not vector.

PS: No animals where harmed while posting this code.

Steve

VeganFanatic17-Jun-10 14:27

17-Jun-10 14:27

This variable N, is that second needed?

My goal...

matrix a;

matrix[0] = {0, 1, 4, 1, 9};
matrix[1] = {....};

and so on, so I am trying to get the vector base template working better

http://www.contract-developer.tk

modified on Thursday, June 17, 2010 8:38 PM

Stephen Hewitt17-Jun-10 14:57

17-Jun-10 14:57

I don't think this kind of thing can be done unless you've got some brand spanking new C++0x[^] compliant compiler. Specifically the C++0x "Initializer lists" feature.

Steve

VeganFanatic17-Jun-10 15:10

17-Jun-10 15:10

Guess I am waiting for Visual Studio 2010 SP1

http://www.contract-developer.tk

Stephen Hewitt17-Jun-10 15:45

17-Jun-10 15:45

Have a look at Boost[^]'s Boost.Assign[^] library.

Steve

VeganFanatic17-Jun-10 15:46

17-Jun-10 15:46

I have looked the std::array and I will see what I can do about casting that to my vector template.

#include <array>

http://www.contract-developer.tk

VeganFanatic17-Jun-10 15:58

17-Jun-10 15:58

That was another waste of time.

Sure seems VC 2010 is hostile to data processing.

http://www.contract-developer.tk

Aescleal17-Jun-10 22:18

Aescleal

17-Jun-10 22:18

If you want to do something with an array and not a pointer to a lump of data then declare the function as:

template <std::size_t N> my_class &operator=(T (&t)[N])

where T is the type you're templating on. Usually what you do is have a copy constructor that takes the same parameters and then you implement operator= in terms of it (which can improve exception saftety as well if you do it right):

template <std::size_t N> my_class &operator=( T (&t)[N] )
{
    my_class temp( t );
    std::swap( temp. *this );
    return *this;
}

The important thing is getting the size of the array into the function.

Another way of doing this, which is common in the STL, is to specify a range of interators, in this case you could use a range of T pointers:

my_class &operator=( const T *begin, const T * const end )

I'd strongly recommend you grab a copy of "Exceptional C++" by Herb Sutter - it's got loads of guidance on how to write assignment operators.

Cheers,

Ash

inheriting std::vector

VeganFanatic17-Jun-10 8:26

17-Jun-10 8:26

a while ago I wrote a vector template to assist in a project, it works OK.

I was considering the effect inheriting the std::vector and make all of the functionality available and simply attach my new functionality on top of that.

Is this practical? Here is the vector as it stands today.

template <class base> class vector {<br />
public:<br />
	std::vector<base> data;<br />
	friend class matrix<base>;<br />
	vector operator+(const vector &that) {			// parallelogram law<br />
		vector ret;<br />
		assert(this->data.size() == that.data.size());<br />
		ret.resize(this->data.size());<br />
		#pragma omp parallel for<br />
		for (int i = 0; i < this->data.size(); i++)<br />
			ret.data[i] = this->data[i] + that.data[i];<br />
		return ret;<br />
	}<br />
	vector operator-(vector that) {				// parallelogram law<br />
		vector ret;<br />
		assert(this->data.size() == that.data.size());<br />
		ret.resize(this->data.size());<br />
		#pragma omp parallel for<br />
		for (int i = 0; i < this->data.size(); i++)<br />
			ret.data[i] = this->data[i] - that.data[i];<br />
		return ret;<br />
	}<br />
	vector operator* (base &that) {				// scalar product<br />
		vector ret;<br />
		ret.resize(this->data.size());<br />
		#pragma omp parallel for<br />
		for (int i = 0; i < this->data.size(); i++)<br />
			ret.data[i] = this->data[i] * that;<br />
		return ret;<br />
	}<br />
	double operator* (vector &that) {			// dot / inner product<br />
		double ret;<br />
		#pragma omp parallel for<br />
		for (int i = 0; i < this->data.size(); i++) <br />
			ret += this->data[i] * that.data[i];  // sum of products of complex numbers is real<br />
		return ret;<br />
	}<br />
	vector operator/ (base &that) {				// scalar division<br />
		vector ret;<br />
		ret.resize(this->data.size());<br />
		#pragma omp parallel for<br />
		for (int i = 0; i < this->data.size(); i++)<br />
			ret.data[i] = this->data[i] / that;<br />
		return ret;<br />
	}<br />
	vector operator= (vector &that) {			// assignment operator<br />
		for (int i=0; i < that.data.size(); i++)<br />
			this->data[i] = that.data[i];<br />
		return *this;<br />
	}<br />
	base& operator[] (size_t index) {			<br />
		return this->data[index];<br />
	}<br />
	bool operator== (vector &that) {			<br />
		bool temp = true;<br />
		for (int i=0; i < that.data.size(); i++)<br />
			if (this->data[i] != that.data[i]) temp = false;<br />
		return temp;<br />
	}<br />
	// the norm is the vector length<br />
	base norm(void) {						<br />
		base result = (base)0.0;<br />
		#pragma omp parallel for<br />
		for (int i = 0; i < this->data.size(); i++) {<br />
			result += this->data[i] * this->data[i];  // sum of products of complex numbers is real<br />
		}<br />
		return sqrt(result);<br />
	}<br />
	// Bring up some of the std:vector functions<br />
	size_t size(void) {<br />
		return data.size();<br />
	}<br />
	vector resize(size_t newsize) {<br />
		data.resize(newsize);<br />
		return *this;<br />
	}<br />
	vector clear(void) {<br />
		data.clear();<br />
		return *this;<br />
	}<br />
};<br />

http://www.contract-developer.tk

Aescleal17-Jun-10 9:12

Aescleal

17-Jun-10 9:12

The general concensus is don't inherit from an STL collection - they're not designed for it.

The two ways I'd recommend going about extending an STL collection is either bundle it up in another class (which you've done) OR just write free functions to do the extended functionality. From your example it looks like you want a geometric vector and not a collection of doodads that might or might not have some geometric relationship.

Incidentally if you want to continue using containment the way you have make the std::vector private. You really don't want a class exposing data through it's public interface, it's really hard to test and some idiot will maul it for you - even if that idiot turns out to be you several months down the line when you've forgotten what you did.

Cheers,

Ash

VeganFanatic17-Jun-10 9:15

17-Jun-10 9:15

I guess I will need to add more accessors then to make it resemble the std::vector

My goal is to resemble the std::vector and bolt on some linear algebra

http://www.contract-developer.tk

C^hris L^osinger17-Jun-10 9:14

17-Jun-10 9:14

it might work, but in general you should avoid inheriting directly from STL containers, if you can. the reason is that these containers do not have virtual destructors, and that may expose you to memory leaks.

http://www.codeguru.com/forum/archive/index.php/t-267641.html[^]

VeganFanatic17-Jun-10 9:18

17-Jun-10 9:18

I find that adding:

template <class base> class vector : std::vector<base>

does not seem to provide a great deal of change? So what impact if any does inheriting the object get me?

http://www.contract-developer.tk

C^hris L^osinger17-Jun-10 9:22

17-Jun-10 9:22

VeganFanatic wrote:
So what impact if any does inheriting the object get me?

again, STL containers do not provide virtual destructors[^]

VeganFanatic17-Jun-10 9:25

17-Jun-10 9:25

Should I simply add more code and add formal constructors and destructors? Go for base* data construct instead?

http://www.contract-developer.tk

C^hris L^osinger17-Jun-10 9:28

17-Jun-10 9:28

VeganFanatic wrote:
Should I simply add more code and add formal constructors and destructors?

no matter what you do, because STL containers do not have virtual dtors, the destructor in your derived class will not be called.

http://www.devx.com/tips/Tip/13509[^]

Stephen Hewitt17-Jun-10 14:05

17-Jun-10 14:05

This is only an issue if he deletes the object through the base class.

Steve

C^hris L^osinger17-Jun-10 16:34

17-Jun-10 16:34

well, i provided as many links to detailed explanations as i could stand to look up.

Emilio Garavaglia18-Jun-10 3:12

Emilio Garavaglia

18-Jun-10 3:12

Chris, those links are "things to be noted" not "the Bible".
The STL itself is designed by inheriting between classes that don't have virtual destructor. Think to iofstream versus istream and ostream

STL containers don't have virtual destructors because they are designed to be non-polymophic and to exist into a closed scope.

If you respect this, that means don't do things like (pseudocode)

vector* p = new myvector;
delete p; //worng: will destroy only "vector" not "myvector"

but just

{
   myvector v;
   //whatever you want with v, including vector functionality
}

you are in any case in a right position.

2 bugs found.
> recompile ...
65534 bugs found.
D'Oh! | :doh:

C^hris L^osinger18-Jun-10 11:17

18-Jun-10 11:17

i thought it would be better to tell the OP where to find relevant information, rather than to try explaining the entire topic and trying to find out which bits he needed to specifically worry about.