By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
446,421 Members | 1,128 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 446,421 IT Pros & Developers. It's quick & easy.

Writing operator functions

P: n/a
Yes, hi

How to write "operator +" and "operator =" functions in a class with
a defined constructor? The following code demonstrates that I don't
really understand how to do it... I think it has something to do with
the compiler calling the destructor twice. Could someone point out
where I go wrong?
P.S.: The error it gives is "Debug Assertion Failure ....." (at run
time)
P.P.S: Everything else works just fine (without the use of "operator
+"
and "operator =" functions)

//code "tested" on Microsoft Visual C++ 6.0
#include <iostream>

using namespace std;

class DatArray {
public:
int rows, columns;
double **a;
DatArray(int r, int c);
~DatArray();
void operator = (double d1);
void operator = (DatArray da1); //problematic
void operator ++ ();
//DatArray operator + (double d1); //does not work
};

DatArray::DatArray(int r, int c) {
int c1;
rows = r;
columns = c;
a = new double* [rows];
for (c1 = 0; c1 < rows; c1++) a[c1] = new double [columns];
}

DatArray::~DatArray() {
int c1;
for (c1 = 0; c1 < rows; c1++) delete [] a[c1];
delete [] a;
}

void DatArray::operator = (double d1) {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2] = d1;
}

void DatArray::operator = (DatArray da1) {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2] = da1.a[c1][c2];
}

void DatArray::operator ++ () {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2]++;
}

/*DatArray DatArray::operator + (double d1) {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2] = a[c1][c2] + d1;
return *this;
}*/

int main() {
int c1, c2;
DatArray myarray(3, 4), myarray2(3, 4);
myarray = 10.1;
for (c1 = 0; c1 < myarray.rows; c1++) {
for (c2 = 0; c2 < myarray.columns; c2++) cout << myarray.a[c1][c2]
<< " ";
cout << endl;
}
cout << endl;
for (c1 = 0; c1 < 100; c1++) myarray++;
//myarray2 = myarray + 100; //this should be simpler, but does not
work ?!?!?!?!?!
myarray2 = myarray;
for (c1 = 0; c1 < myarray.rows; c1++) {
for (c2 = 0; c2 < myarray.columns; c2++) cout << myarray2.a[c1][c2]
<< " ";
cout << endl;
}
cin.get(); //currently, after this, ERROR ... WHY?!?!?!?!?! (how to
fix this?!?!?!?!?)
return 0;
}
//end of code "tested" on Microsoft Visual C++ 6.0

Thanks,
Valerij

Mar 14 '07 #1
Share this Question
Share on Google+
8 Replies


P: n/a
valerij wrote:
Yes, hi

How to write "operator +" and "operator =" functions in a class with
a defined constructor? The following code demonstrates that I don't
really understand how to do it... I think it has something to do with
the compiler calling the destructor twice. Could someone point out
where I go wrong?
P.S.: The error it gives is "Debug Assertion Failure ....." (at run
time)
P.P.S: Everything else works just fine (without the use of "operator
+"
and "operator =" functions)

//code "tested" on Microsoft Visual C++ 6.0
#include <iostream>

using namespace std;

class DatArray {
public:
int rows, columns;
double **a;
DatArray(int r, int c);
~DatArray();
void operator = (double d1);
void operator = (DatArray da1); //problematic
void operator ++ ();
//DatArray operator + (double d1); //does not work
};
My gut instinct tells me you are missing a Copy Constructor.
I'd have to look at it closely to tell later :)
Mar 14 '07 #2

P: n/a
valerij wrote:
Yes, hi

How to write "operator +" and "operator =" functions in a class with
a defined constructor? The following code demonstrates that I don't
really understand how to do it... I think it has something to do with
the compiler calling the destructor twice. Could someone point out
where I go wrong?
P.S.: The error it gives is "Debug Assertion Failure ....." (at run
time)
P.P.S: Everything else works just fine (without the use of "operator
+"
and "operator =" functions)

//code "tested" on Microsoft Visual C++ 6.0
#include <iostream>

using namespace std;

class DatArray {
public:
int rows, columns;
double **a;
DatArray(int r, int c);
~DatArray();
void operator = (double d1);
void operator = (DatArray da1); //problematic

You've violated the "Rule of Three". Look it up. Also, consider
that operator = (the assignment op) should probably take a ref to
a const object instead of an object.
void operator ++ ();
//DatArray operator + (double d1); //does not work
};
[..]
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
Mar 14 '07 #3

P: n/a
On Mar 14, 2:05 pm, "valerij" <valerij.rozou...@gmail.comwrote:
How to write "operator +" and "operator =" functions in a class with
a defined constructor?
[snip]

Read FAQs 16.16 thru 16.19. They present several ways to create a 2-D
array (i.e., at Matrix) class:

http://www.parashift.com/c++-faq-lit...html#faq-16.16

Cheers! --M

Mar 14 '07 #4

P: n/a
On 14 Mar 2007 11:05:35 -0700 in comp.lang.c++, "valerij"
<va**************@gmail.comwrote,
>How to write "operator +" and "operator =" functions in a class with
a defined constructor?
operator+ should usually be

T operator+(T const & t1, T const & t2)
{
T result(t1);
result += t2;
return result;
}

operator= depends on the requirements of your class, but usually
you just use operator= of each of the base classes and members.
(That is the compiler supplied operator= if you do not write one,
but unfortunately you have to write += yourself.)

operator+= is a lot like operator= except using += instead of =.
All the = operators (if you need them) should be members.
>//code "tested" on Microsoft Visual C++ 6.0
Failure to upgrade to at least MSVC 7.x may be harmful to your sanity.
>class DatArray {
public:
int rows, columns;
double **a;
std::vector<std::vector<double a;

>DatArray::DatArray(int r, int c) {
DatArray::DatArray(int r, int c)
: a(r, std::vector<double>(c))
{ }
>/*DatArray DatArray::operator + (double d1) {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2] = a[c1][c2] + d1;
return *this;
}*/
DatArray & DatArray::operator += (double d1) {
for (int c1 = 0; c1 < a.size(); c1++)
for (int c2 = 0; c2 < a[c1].size(); c2++)
a[c1][c2] += d1;
return *this;
}

Mar 14 '07 #5

P: n/a
On Mar 14, 1:05 pm, "valerij" <valerij.rozou...@gmail.comwrote:
Yes, hi

How to write "operator +" and "operator =" functions in a class with
a defined constructor? The following code demonstrates that I don't
really understand how to do it... I think it has something to do with
the compiler calling the destructor twice. Could someone point out
where I go wrong?
P.S.: The error it gives is "Debug Assertion Failure ....." (at run
time)
P.P.S: Everything else works just fine (without the use of "operator
+"
and "operator =" functions)

//code "tested" on Microsoft Visual C++ 6.0
#include <iostream>

using namespace std;

class DatArray {
public:
int rows, columns;
double **a;
DatArray(int r, int c);
~DatArray();
void operator = (double d1);
void operator = (DatArray da1); //problematic
void operator ++ ();
//DatArray operator + (double d1); //does not work

};

DatArray::DatArray(int r, int c) {
int c1;
rows = r;
columns = c;
a = new double* [rows];
for (c1 = 0; c1 < rows; c1++) a[c1] = new double [columns];

}

DatArray::~DatArray() {
int c1;
for (c1 = 0; c1 < rows; c1++) delete [] a[c1];
delete [] a;

}

void DatArray::operator = (double d1) {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2] = d1;

}

void DatArray::operator = (DatArray da1) {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2] = da1.a[c1][c2];

}

void DatArray::operator ++ () {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2]++;

}

/*DatArray DatArray::operator + (double d1) {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2] = a[c1][c2] + d1;
return *this;

}*/

int main() {
int c1, c2;
DatArray myarray(3, 4), myarray2(3, 4);
myarray = 10.1;
for (c1 = 0; c1 < myarray.rows; c1++) {
for (c2 = 0; c2 < myarray.columns; c2++) cout << myarray.a[c1][c2]
<< " ";
cout << endl;
}
cout << endl;
for (c1 = 0; c1 < 100; c1++) myarray++;
//myarray2 = myarray + 100; //this should be simpler, but does not
work ?!?!?!?!?!
myarray2 = myarray;
for (c1 = 0; c1 < myarray.rows; c1++) {
for (c2 = 0; c2 < myarray.columns; c2++) cout << myarray2.a[c1][c2]
<< " ";
cout << endl;
}
cin.get(); //currently, after this, ERROR ... WHY?!?!?!?!?! (how to
fix this?!?!?!?!?)
return 0;}

//end of code "tested" on Microsoft Visual C++ 6.0

Thanks,
Valerij
Hi again,

I seem to have figured it out. You have to use pointers. The working
code is below. My next question is how to implement the following:

DatArray* operator + (DatArray da1);

Thanks,
Valerij

//code tested on Microsoft Visual C++ 6.0
#include <iostream>

using namespace std;

class DatArray {
public:
int rows, columns;
int name;
double **a;
DatArray(int r, int c);
~DatArray();
void operator = (double d1);
void operator = (int i1);
void operator = (DatArray* da1);
DatArray* operator + (double d1);
DatArray* operator - (double d1);
DatArray* operator * (double d1);
DatArray* operator / (double d1);
void operator ++ ();
void operator -- ();
};

DatArray::DatArray(int r, int c) {
int c1;
rows = r;
columns = c;
a = new double* [rows];
for (c1 = 0; c1 < rows; c1++) a[c1] = new double [columns];
name = 0;
}

DatArray::~DatArray() {
int c1;
cout << "Destroying " << name << endl;
for (c1 = 0; c1 < rows; c1++) delete [] a[c1];
delete [] a;
}

void DatArray::operator = (double d1) {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2] = d1;
}

void DatArray::operator = (int i1) {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2] = i1;
}

void DatArray::operator = (DatArray* da1) {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2] = da1->a[c1][c2];
}

void DatArray::operator ++ () {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2]++;
}

void DatArray::operator -- () {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2]--;
}

DatArray* DatArray::operator + (double d1) {
int c1, c2;
DatArray *da1;
da1 = new DatArray(rows, columns);
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) da1->a[c1][c2] = a[c1][c2] + d1;
return da1;
}

DatArray* DatArray::operator - (double d1) {
int c1, c2;
DatArray *da1;
da1 = new DatArray(rows, columns);
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) da1->a[c1][c2] = a[c1][c2] - d1;
return da1;
}

DatArray* DatArray::operator * (double d1) {
int c1, c2;
DatArray *da1;
da1 = new DatArray(rows, columns);
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) da1->a[c1][c2] = a[c1][c2] * d1;
return da1;
}

DatArray* DatArray::operator / (double d1) {
int c1, c2;
DatArray *da1;
da1 = new DatArray(rows, columns);
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) da1->a[c1][c2] = a[c1][c2] / d1;
return da1;
}

int main() {
int c1, c2;
DatArray myarray(3, 4), myarray2(3, 4);

myarray.name = 1;
myarray2.name = 2;

myarray = 0;
myarray2 = 300;
myarray = myarray2 + 1000;
myarray2 = myarray / 100;

for (c1 = 0; c1 < myarray.rows; c1++) {
for (c2 = 0; c2 < myarray.columns; c2++) cout << myarray.a[c1][c2]
<< " ";
cout << endl;
}
cout << endl;
for (c1 = 0; c1 < myarray.rows; c1++) {
for (c2 = 0; c2 < myarray.columns; c2++) cout << myarray2.a[c1][c2]
<< " ";
cout << endl;
}

return 0;
}
//end of code tested on Microsoft Visual C++ 6.0

Mar 14 '07 #6

P: n/a
On Mar 14, 1:22 pm, "Victor Bazarov" <v.Abaza...@comAcast.netwrote:
valerij wrote:
Yes, hi
How to write "operator +" and "operator =" functions in a class with
a defined constructor? The following code demonstrates that I don't
really understand how to do it... I think it has something to do with
the compiler calling the destructor twice. Could someone point out
where I go wrong?
P.S.: The error it gives is "Debug Assertion Failure ....." (at run
time)
P.P.S: Everything else works just fine (without the use of "operator
+"
and "operator =" functions)
//code "tested" on Microsoft Visual C++ 6.0
#include <iostream>
using namespace std;
class DatArray {
public:
int rows, columns;
double **a;
DatArray(int r, int c);
~DatArray();
void operator = (double d1);
void operator = (DatArray da1); //problematic

You've violated the "Rule of Three". Look it up. Also, consider
that operator = (the assignment op) should probably take a ref to
a const object instead of an object.
void operator ++ ();
//DatArray operator + (double d1); //does not work
};
[..]

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
OMG. I never heard of it ... just looking at it now ... this might
just be what i always wanted to know ...
thanks

Mar 14 '07 #7

P: n/a
On Mar 14, 1:58 pm, David Harmon <sou...@netcom.comwrote:
On 14 Mar 2007 11:05:35 -0700 in comp.lang.c++, "valerij"
<valerij.rozou...@gmail.comwrote,
How to write "operator +" and "operator =" functions in a class with
a defined constructor?

operator+ should usually be

T operator+(T const & t1, T const & t2)
{
T result(t1);
result += t2;
return result;
}

operator= depends on the requirements of your class, but usually
you just use operator= of each of the base classes and members.
(That is the compiler supplied operator= if you do not write one,
but unfortunately you have to write += yourself.)

operator+= is a lot like operator= except using += instead of =.
All the = operators (if you need them) should be members.
//code "tested" on Microsoft Visual C++ 6.0

Failure to upgrade to at least MSVC 7.x may be harmful to your sanity.
class DatArray {
public:
int rows, columns;
double **a;

std::vector<std::vector<double a;
DatArray::DatArray(int r, int c) {

DatArray::DatArray(int r, int c)
: a(r, std::vector<double>(c))
{ }
/*DatArray DatArray::operator + (double d1) {
int c1, c2;
for (c1 = 0; c1 < rows; c1++)
for (c2 = 0; c2 < columns; c2++) a[c1][c2] = a[c1][c2] + d1;
return *this;
}*/

DatArray & DatArray::operator += (double d1) {
for (int c1 = 0; c1 < a.size(); c1++)
for (int c2 = 0; c2 < a[c1].size(); c2++)
a[c1][c2] += d1;
return *this;

}
You see, I have Windows 98SE, so any higher and it will be just too
slow ;)

Mar 14 '07 #8

P: n/a
On 14 Mar 2007 12:50:26 -0700 in comp.lang.c++, "valerij"
<va**************@gmail.comwrote,
>You see, I have Windows 98SE, so any higher and it will be just too
slow ;)
OK, that's a side issue. Don't neglect the part about getting rid of
the raw pointers and raw arrays. Prefer std::vector in application
level code.

Digital Mars C++ is very efficient under '98, and far more standard-
conforming than VC6. http://digitalmars.com

Mar 15 '07 #9

This discussion thread is closed

Replies have been disabled for this discussion.