Why the destructor is called?

Hello everyone!

I'm coding an application and I don't understand why it isn't working. I've written a simple example to show you my problem:

Code:

#include <iostream>
using std::cout;

class test {
friend test operator+(test&, test&);

public:
test() {}
test(const int& s1, const int& s2);
double& operator ()(int i, int j) {return v[i][j];}
~test();

protected:
double** v;
int _s1, _s2;
};

int main() {
test t(4, 4);
test a(4, 4);
test b(4, 4);

for (int i = 0; i < 4; i++) {
a(i, i) = i;
b(i, i) = i + 2;
}

t = a + b;
for (int i = 0; i < 4; i++){
for (int j = 0; j < 4; j++)
cout << t(i, j) << " ";
cout << "\n";
}

system("pause");

return 0;
}

test operator+(test& a, test& b)
{
test z(a._s1, a._s2);
for(int i = 0; i < a._s1; i++){
for (int j = 0; j < a._s2; j++)
z(i, j) = a(i, j) + b(i, j);
}

return z;
}

test::test(const int& s1, const int& s2) {
v = new double*[s1];
for (int i = 0; i < s1; i++)
v[i] = new double[s2];

_s1 = s1;
_s2 = s2;

for (int i = 0; i < s1; i++){
for (int j = 0; j < s2; j++)
v[i][j] = 0.0;
}
}

test::~test() {
for (int i = 0; i < _s1; i++)
delete [] v[i];
delete [] v;
}

The problem is that when I do "t = a + b;" the "return z" in the function "test operator+(test&, test&);" it calls the destructor for z before it returns and this makes a crash because the variable t doesn't have anything.

Also, the destructor for "t" is called right after the return from the function causing another crash.

The interesting part is that if I adapt the code to sum vectors intead of matrices, it works!

Any help would be appreciated.

Thanks,

scherzo

Actually, the problem is that you haven't got a copy/assignment operator for your class, so when you delete the z's v[] (which is done correctly after the "return z" has been copied to the t variable in your main). You can see the t value change to the same value as the z if you look at a memory view of the t memory.

The correct thing to do is not to copy the v pointer, but to copy the CONTENT of v.

--
Mats

I added the following:

Code:

test::test(test &t)
{
	int i;
	v = new double*[t._s1];
	for (i = 0; i < t._s1; i++)
		v[i] = new double[t._s2];
	_s1 = t._s1;
	_s2 = t._s2;

	for(i = 0; i < t._s1; i++) {
		for(int j = 0; j < t._s2; j++) 
			v[i][j] = t.v[i][j];
	}
}


test & test::operator=(const test &t)
{
	assert(t._s2 == _s2 && t._s1 == _s1);
	for(int i = 0; i < t._s1; i++) {
		for(int j = 0; j < t._s2; j++) 
			v[i][j] = t.v[i][j];
	}
	return *this;
}

And now the program executes correctly.

Code:

Output:
2 0 0 0
0 4 0 0
0 0 6 0
0 0 0 8

You probably also want to add const as marked with red:

Code:

test operator+(const test& a, const test& b)
	double& operator ()(int i, int j) const {return v[i][j];}

--
Mats

[quote]

Code:

test & test::operator=(const test &t)
{
	assert(t._s2 == _s2 && t._s1 == _s1);

Which makes me wonder, wouldn't the correct behaviour - instead of asserting - be to resize the array.

All in all, there might be much less trouble if you used a std::vector<std::vector<double> > instead of a double** (where vector is a container for dynamically allocated array).

[QUOTE=anon;681089]

Code:

test & test::operator=(const test &t)
{
	assert(t._s2 == _s2 && t._s1 == _s1);

Which makes me wonder, wouldn't the correct behaviour - instead of asserting - be to resize the array.

All in all, there might be much less trouble if you used a std::vector<std::vector<double> > instead of a double** (where vector is a container for dynamically allocated array).

Probably right there. I just put the assert in to convince myself that it wasn't complete rubbish. Since all of the code uses one size, it would only fire if the object wasn't properly initialized.

--
Mats

Thanks for all matsp and anon.

Now I know what was going on.

Best regards,

scherzo