«

ComplexNum ComplexNum:perator +(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:perator += (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?

On Jun 15, 12:35 am, Sam <s...@email-scan.com> wrote:
> foolsmart2...@gmail.com writes:
> > for += operation, my code is:
> > ComplexNum ComplexNum:perator += (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.

On Jun 15, 12:35 am, Sam <s...@email-scan.com> wrote:
> foolsmart2...@gmail.com writes:
> > for += operation, my code is:
> > ComplexNum ComplexNum:perator += (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);

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

Hi!

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

On Jun 14, 10:08*pm, "foolsmart2...@gmail.com"
<foolsmart2...@gmail.com> wrote:
> On Jun 15, 12:35 am, Sam <s...@email-scan.com> wrote:
> > foolsmart2...@gmail.com writes:
> > > for += operation, my code is:
> > > ComplexNum ComplexNum:perator += (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.

On 2008-06-14 18:20, wrote:
> ComplexNum ComplexNum:perator +(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:perator += (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

On Jun 15, 9:57 am, "Daniel T." <danie...@earthlink.net> wrote:
> "foolsmart2...@gmail.com" <foolsmart2...@gmail.com> wrote:
> > ComplexNum ComplexNum:perator +(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:perator += (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:perator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real+= rhs.real;
imaginary += rhs.imaginary;
}
return *this;
}

is it correct?

> This time my code is:
>
> ComplexNum& ComplexNum:perator += (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.

On Jun 15, 11:05 am, Sze <kamistrik...@googlemail.com> wrote:
> > This time my code is:
>
> > ComplexNum& ComplexNum:perator += (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:perator += (const ComplexNum& rhs)
{
if(&rhs != this)
{
real= real+rhs.real;
imaginary = imaginary+ rhs.imaginary;
}
return *this;
}

?