+= operation

[foolsmart2005]

ComplexNum ComplexNum::operator +(const ComplexNum& rhs) const //
- operation is the similar way
{
ComplexNum ans;
ans.real = real + rhs.real;
ans.imaginary = imaginary + rhs.imaginary;
return ans;
}

it works and my lecturer said it is correct but,
for += operation, my code is:
ComplexNum ComplexNum::operator += (const ComplexNum& rhs) const
{
ComplexNum ans;
ans.real += rhs.real;
ans.imaginary += rhs.imaginary;
return ans;
}

here is lecturer's comment:
+= should be different. a += b means a = a + b
therefore *this object (i.e. a) should be updated with the answer.

Do anyone know how to write += operation?

[Sam]

fo***********@gmail.com writes:

for += operation, my code is:
ComplexNum ComplexNum::operator += (const ComplexNum& rhs) const
{
ComplexNum ans;
ans.real += rhs.real;
ans.imaginary += rhs.imaginary;
return ans;
}

here is lecturer's comment:
+= should be different. a += b means a = a + b

Your lecturer should've also told you that your results are undefined since
the contents of the ans object are, apparently, not initialized. Your +=
operation on ans's members are applied to, apparently, uninitialized members
of this object. This would be the same as writing:

int x;

x += 4;

Obviously, the results of this are undefined.

therefore *this object (i.e. a) should be updated with the answer.

Correct.

Do anyone know how to write += operation?

Yes, but why don't you try to figure this out yourself. Look around, there
are plenty of examples of assignment operators for other classes. Here are
two free clues:

1) operator += modifies this object, therefore it cannot be a const
function (well, it can be, but you're not there, yet).

2) The assignment operator, be it operator =(), operator +=(), operator
-=(), or anything else, traditional does not return another instance of the
object, but rather a reference to this, modified, object.

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (GNU/Linux)

iEYEABECAAYFAkhT81gACgkQx9p3GYHlUOKqFgCfTH21mCsaDH j6G3oDZ8WKtuw9
VMMAn3BxWQphDs5vEcoBgvba0JX5/fcu
=KvB4
-----END PGP SIGNATURE-----

[foolsmart2005]

On Jun 15, 12:35 am, Sam <[e-mail]:

[e-mail] writes:

for += operation, my code is:
ComplexNum ComplexNum::operator += (const ComplexNum& rhs) const
{
ComplexNum ans;
ans.real += rhs.real;
ans.imaginary += rhs.imaginary;
return ans;
}

here is lecturer's comment:
+= should be different. a += b means a = a + b

Your lecturer should've also told you that your results are undefined since
the contents of the ans object are, apparently, not initialized. Your +=
operation on ans's members are applied to, apparently, uninitialized members
of this object. This would be the same as writing:

int x;

x += 4;

Obviously, the results of this are undefined.

therefore *this object (i.e. a) should be updated with the answer.

Correct.

Do anyone know how to write += operation?

Yes, but why don't you try to figure this out yourself. Look around, there
are plenty of examples of assignment operators for other classes. Here are
two free clues:

1) operator += modifies this object, therefore it cannot be a const
function (well, it can be, but you're not there, yet).

2) The assignment operator, be it operator =(), operator +=(), operator
-=(), or anything else, traditional does not return another instance of the
object, but rather a reference to this, modified, object.

application_pgp-signature_part
1KDownload

Of course I have searched the Internet but, on Google, I type +=
operation, it cannot detect '+='. That's why I find unsuitable ones.

[foolsmart2005]

On Jun 15, 12:35 am, Sam <[e-mail]:

[e-mail] writes:

for += operation, my code is:
ComplexNum ComplexNum::operator += (const ComplexNum& rhs) const
{
ComplexNum ans;
ans.real += rhs.real;
ans.imaginary += rhs.imaginary;
return ans;
}

here is lecturer's comment:
+= should be different. a += b means a = a + b

Your lecturer should've also told you that your results are undefined since
the contents of the ans object are, apparently, not initialized. Your +=
operation on ans's members are applied to, apparently, uninitialized members
of this object. This would be the same as writing:

int x;

x += 4;

Obviously, the results of this are undefined.

therefore *this object (i.e. a) should be updated with the answer.

Correct.

Do anyone know how to write += operation?

Yes, but why don't you try to figure this out yourself. Look around, there
are plenty of examples of assignment operators for other classes. Here are
two free clues:

1) operator += modifies this object, therefore it cannot be a const
function (well, it can be, but you're not there, yet).

2) The assignment operator, be it operator =(), operator +=(), operator
-=(), or anything else, traditional does not return another instance of the
object, but rather a reference to this, modified, object.

application_pgp-signature_part
1KDownload

is this time correct?
ComplexNum operator += (const ComplexNum& in1, const ComplexNum& in2)
{
ComplexNum ans;
ans.real = in1.real + in2.real;
ans.imaginary = in1.imaginary + in2.imaginary;
return ans;
}

I make it a friend function.
friend ComplexNum operator+=(const ComplexNum& in1, const ComplexNum&
in2);

[Frank Birbacher]

Hi!

Sam schrieb:

This would be the same as writing:

int x;

x += 4;

The class could have a default constructor which initializes the
members, though.

Frank

[Frank Birbacher]

Hi!

fo***********@gmail.com schrieb:

Of course I have searched the Internet but, on Google, I type +=
operation, it cannot detect '+='. That's why I find unsuitable ones.

This should help:
http://www.google.com/search?q=c%2B%...btnG=Suche&lr=

Regards,
Frank

[Abhishek Padmanabh]

On Jun 14, 10:08*pm, "[e-mail]"
<[e-mail]:

On Jun 15, 12:35 am, Sam <[e-mail]:

[e-mail] writes:

for += operation, my code is:
ComplexNum ComplexNum::operator += (const ComplexNum& rhs) const
{
* * * * * *ComplexNum ans;
* * * * * *ans.real += rhs.real;
* * * * * *ans.imaginary += rhs.imaginary;
* * * * * *return ans;
*}

here is lecturer's comment:
+= should be different. a += b means a = a + b

Your lecturer should've also told you that your results are undefined since
the contents of the ans object are, apparently, not initialized. Your +=
operation on ans's members are applied to, apparently, uninitialized members
of this object. This would be the same as writing:

* *int x;

* *x += 4;

Obviously, the results of this are undefined.

therefore *this object (i.e. a) should be updated with the answer.

Correct.

Do anyone know how to write += operation?

Yes, but why don't you try to figure this out yourself. Look around, there
are plenty of examples of assignment operators for other classes. Here are
two free clues:

1) operator += modifies this object, therefore it cannot be a const
function (well, it can be, but you're not there, yet).

2) The assignment operator, be it operator =(), operator +=(), operator
-=(), or anything else, traditional does not return another instance of the
object, but rather a reference to this, modified, object.

*application_pgp-signature_part
1KDownload

is this time correct?
ComplexNum operator += (const ComplexNum& in1, const ComplexNum& in2)
{
* * * * * *ComplexNum ans;
* * * * * *ans.real = in1.real + in2.real;
* * * * * *ans.imaginary = in1.imaginary + in2.imaginary;
* * * * * *return ans;
*}

I make it a friend function.
friend ComplexNum operator+=(const ComplexNum& in1, const ComplexNum&
in2);

No. It is not correct yet. The idea is to have operator+= as a non-
static member function, that's how you get a 'this' argument with it
and hence it would just be needing one argument instead of two.
Whatever you are doing with the local object 'ans' should be done with
the '*this' object.

When you get the operator+= working, as a next step, try to write
operator+ in terms of it (operator+=). So that, at least you have to
maintain the code of just one of those two operators.

[Sam]

fo***********@gmail.com writes:

>
is this time correct?
ComplexNum operator += (const ComplexNum& in1, const ComplexNum& in2)
{
ComplexNum ans;
ans.real = in1.real + in2.real;
ans.imaginary = in1.imaginary + in2.imaginary;
return ans;
}

I make it a friend function.

This is only correct in the sense that this is syntactically valid C++ code,
but this is not the correct implementation of the += operator.

What you have above is really operator +, the regular addition operator.
There's no difference between operator +, and your operator +=.

The crucial difference is that the += operator modifies its left operand,
and operator + does not. operator + returns a new object, that's defined by
the addition operator on its two operands. This is really what your code,
above, does, and it's not the same thing as the += operator. The += operator
modifies its left-hand operator, while your code leaves it alone.

With your implementation of the += operator, the following statement:

in1 += in2;

leaves the value of in1 completely unmodified, while in practice you expect
in1's value to be changed by the += operator. Run a test program, using your
friend function implementation of the += operator, and see for yourself.
This is clearly wrong. Also, the assignment operators are NOT usually
implemented as friend functions, but as regular class methods.

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (GNU/Linux)

iEYEABECAAYFAkhUC6QACgkQx9p3GYHlUOKQjgCfaf+CDFIW13 l/BCkUxFZzWIvK
/c8AniaTgb12ug+mLbSYg2WRywYuiLG7
=eZoj
-----END PGP SIGNATURE-----

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2008-06-14 18:20, fo***********@gmail.com wrote:

ComplexNum ComplexNum::operator +(const ComplexNum& rhs) const //
- operation is the similar way
{
ComplexNum ans;
ans.real = real + rhs.real;
ans.imaginary = imaginary + rhs.imaginary;
return ans;
}

it works and my lecturer said it is correct but,
for += operation, my code is:
ComplexNum ComplexNum::operator += (const ComplexNum& rhs) const
{
ComplexNum ans;
ans.real += rhs.real;
ans.imaginary += rhs.imaginary;
return ans;
}

here is lecturer's comment:
+= should be different. a += b means a = a + b
therefore *this object (i.e. a) should be updated with the answer.

Do anyone know how to write += operation?

In the += case you want to add the values in rhs to the values of the
complex number on the left hand side (which will be "this" in the body
of the += operator. The += operator should also return a reference to
the number on the left hand side instead of a new object containing the
value of the operation.

--
Erik Wikström

[Daniel T.]

"fo***********@gmail.com" <fo***********@gmail.comwrote:

ComplexNum ComplexNum::operator +(const ComplexNum& rhs) const //
- operation is the similar way
{
ComplexNum ans;
ans.real = real + rhs.real;
ans.imaginary = imaginary + rhs.imaginary;
return ans;
}

it works and my lecturer said it is correct but,
for += operation, my code is:
ComplexNum ComplexNum::operator += (const ComplexNum& rhs) const
{
ComplexNum ans;
ans.real += rhs.real;
ans.imaginary += rhs.imaginary;
return ans;
}

here is lecturer's comment:
+= should be different. a += b means a = a + b
therefore *this object (i.e. a) should be updated with the answer.

Do anyone know how to write += operation?

class ComplexNum
{
public:
ComplexNum& operator+=( const ComplexNum& rhs )
{
// add code here
return *this;
}
// everything else
};

int main() {
ComplexNum a( 1, 2 );
ComplexNum b( 3, 5 );
a += b;
assert( a.real() == 4 );
assert( a.imag() == 7 );
cout << "OK\n";
}

Your mission is to add code where it say "add code here" so that the
main function will print "OK" instead of asserting.

[foolsmart2005]

On Jun 15, 9:57 am, "Daniel T." <[e-mail]:

"[e-mail]" <[e-mail]:

ComplexNum ComplexNum::operator +(const ComplexNum& rhs) const //
- operation is the similar way
{
ComplexNum ans;
ans.real = real + rhs.real;
ans.imaginary = imaginary + rhs.imaginary;
return ans;
}

it works and my lecturer said it is correct but,
for += operation, my code is:
ComplexNum ComplexNum::operator += (const ComplexNum& rhs) const
{
ComplexNum ans;
ans.real += rhs.real;
ans.imaginary += rhs.imaginary;
return ans;
}

here is lecturer's comment:
+= should be different. a += b means a = a + b
therefore *this object (i.e. a) should be updated with the answer.

Do anyone know how to write += operation?

class ComplexNum
{
public:
ComplexNum& operator+=( const ComplexNum& rhs )
{
// add code here
return *this;
}
// everything else

};

int main() {
ComplexNum a( 1, 2 );
ComplexNum b( 3, 5 );
a += b;
assert( a.real() == 4 );
assert( a.imag() == 7 );
cout << "OK\n";

}

Your mission is to add code where it say "add code here" so that the
main function will print "OK" instead of asserting.

This time my code is:

ComplexNum& ComplexNum::operator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real+= rhs.real;
imaginary += rhs.imaginary;
}
return *this;
}

is it correct?

[Sze]

This time my code is:

>
ComplexNum& ComplexNum::operator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real+= rhs.real;
imaginary += rhs.imaginary;
}
return *this;
}

is it correct?

Why shouldn`t you allow addition to itself?
I think it does make sense to allow it, this is another case as with
the assignment operator.

[foolsmart2005]

On Jun 15, 11:05 am, Sze <[e-mail]:

This time my code is:

ComplexNum& ComplexNum::operator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real+= rhs.real;
imaginary += rhs.imaginary;
}
return *this;
}

is it correct?

Why shouldn`t you allow addition to itself?
I think it does make sense to allow it, this is another case as with
the assignment operator.

Do you mean this:
ComplexNum& ComplexNum::operator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real= real+rhs.real;
imaginary = imaginary+ rhs.imaginary;
}
return *this;
}

?

[Kai-Uwe Bux]

fo***********@gmail.com wrote:

On Jun 15, 11:05 am, Sze <[e-mail]:

This time my code is:

ComplexNum& ComplexNum::operator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real+= rhs.real;
imaginary += rhs.imaginary;
}
return *this;
}

is it correct?

Why shouldn`t you allow addition to itself?
I think it does make sense to allow it, this is another case as with
the assignment operator.

Do you mean this:
ComplexNum& ComplexNum::operator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real= real+rhs.real;
imaginary = imaginary+ rhs.imaginary;
}
return *this;
}

No.

You made the first test case work. Now, also do this one (without breaking
the first):

int main() {
ComplexNum a( 1, 2 );
a += a;
assert( a.real() == 2 );
assert( a.imag() == 4 );
cout << "OK\n";
}

Best

Kai-Uwe Bux

[Daniel T.]

In article <g3**********@aioe.org>, Kai-Uwe Bux <jk********@gmx.net>
wrote:

fo***********@gmail.com wrote:

On Jun 15, 11:05 am, Sze <[e-mail]:

This time my code is:

ComplexNum& ComplexNum::operator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real+= rhs.real;
imaginary += rhs.imaginary;
}
return *this;
}

is it correct?

Why shouldn`t you allow addition to itself?
I think it does make sense to allow it, this is another case as with
the assignment operator.

Do you mean this:
ComplexNum& ComplexNum::operator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real= real+rhs.real;
imaginary = imaginary+ rhs.imaginary;
}
return *this;
}

No.

You made the first test case work. Now, also do this one (without breaking
the first):

int main() {
ComplexNum a( 1, 2 );
a += a;
assert( a.real() == 2 );
assert( a.imag() == 4 );
cout << "OK\n";
}

Here's a way to test both cases at once...

int main() {
{
ComplexNum a( 1, 2 );
ComplexNum b( 3, 5 );
a += b;
assert( a.real() == 4 );
assert( a.imag() == 7 );
}
{
ComplexNum a( 1, 2 );
a += a;
assert( a.real() == 2 );
assert( a.imag() == 4 );
}
cout << "OK\n";
}

Use the above main and try to get the program to print "OK".

(P.S., welcome to test-first programming. :-)

[foolsmart2005]

On Jun 15, 11:45 am, Kai-Uwe Bux <[e-mail]:

[e-mail] wrote:

On Jun 15, 11:05 am, Sze <[e-mail]:

This time my code is:

ComplexNum& ComplexNum::operator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real+= rhs.real;
imaginary += rhs.imaginary;
}
return *this;
}

is it correct?

Why shouldn`t you allow addition to itself?
I think it does make sense to allow it, this is another case as with
the assignment operator.

Do you mean this:
ComplexNum& ComplexNum::operator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real= real+rhs.real;
imaginary = imaginary+ rhs.imaginary;
}
return *this;
}

No.

You made the first test case work. Now, also do this one (without breaking
the first):

int main() {
ComplexNum a( 1, 2 );
a += a;
assert( a.real() == 2 );
assert( a.imag() == 4 );
cout << "OK\n";

}

Best

Kai-Uwe Bux

for a +=a; this one, I have no idea. How can I do this?

[Kai-Uwe Bux]

fo***********@gmail.com wrote:

On Jun 15, 11:45 am, Kai-Uwe Bux <[e-mail]:

>[e-mail] wrote:

On Jun 15, 11:05 am, Sze <[e-mail]:
This time my code is:

ComplexNum& ComplexNum::operator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real+= rhs.real;
imaginary += rhs.imaginary;
}
return *this;
}

is it correct?

>Why shouldn`t you allow addition to itself?
I think it does make sense to allow it, this is another case as with
the assignment operator.

Do you mean this:
ComplexNum& ComplexNum::operator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real= real+rhs.real;
imaginary = imaginary+ rhs.imaginary;
}
return *this;
}

No.

You made the first test case work. Now, also do this one (without
breaking the first):

int main() {
ComplexNum a( 1, 2 );
a += a;
assert( a.real() == 2 );
assert( a.imag() == 4 );
cout << "OK\n";

}

Best

Kai-Uwe Bux

for a +=a; this one, I have no idea. How can I do this?

Hint: ask yourself why you insist on the if(&rhs != this) check.
Best

Kai-Uwe Bux