Help overloading + and += simultaneously??

[John Hardin]

All:

The syntax for overloading the "+" and other simple binary math operators
is pretty straightforward, but I can't seem to wrap my brain around the
idea that overloading the "+" operator simultaneously overloads the "+="
operator.

Here's the problem I'm having with it:

When you overload a binary operator like "+", you accept two arguments and
you return a new object that holds the result. That's straightforward.

But if the overload of the "+" operator returns a *new* object, how can
that same overload be used to implement the "+=" operator, which is a
change to an *existing* object?

I just can't see how you can overload "+" and "+=" with the same code. Can
somebody help me understand this by pointing me to where this is
explained, or by explaining it to me?

Thanks.

--
John Hardin KA7OHZ ICQ#15735746 http://www.impsec.org/~jhardin/
jh*****@impsec.org FALaholic #11174 pgpk -a jh*****@impsec.org
key: 0xB8732E79 - 2D8C 34F4 6411 F507 136C AF76 D822 E6E6 B873 2E79

[Niki Estner]

"John Hardin" <jh*****@impsec.org> wrote in
news:pa**************************@impsec.org...

... if the overload of the "+" operator returns a *new* object, how can
that same overload be used to implement the "+=" operator, which is a
change to an *existing* object?

Probably the C# designers had primarily value types and immutable reference
types in mind. Take for examples:

string a,b;
a = b = "Test-String";
a += "Suffix";
Console.WriteLine("a = {0}, b = {1}", a,b);

or

int a,b;
a = b = 5;
a += 1;
Console.WriteLine("a = {0}, b = {1}", a,b);

In both cases "a" will be modified, but "b" will not.
C# will mimic exactly that behaviour if you override the "+" operator.

If you're used to C-style "p = &x; *p += 2;" statements, this might be
counter-intuitive, but if you're honest, that kind of code was always
error-prone, and got quite rare due to C#'s stricter type system anyway.

Niki

[Paul E Collins]

"John Hardin" <jh*****@impsec.org> wrote:

When you overload a binary operator like "+", you
accept two arguments and you return a new object
that holds the result. That's straightforward.
But if the overload of the "+" operator returns a *new*
object, how can that same overload be used to implement
the "+=" operator, which is a change to an *existing*
object?

Because a += b is just shorthand for a = a + b.

P.

[Simon Smith]

On 27 Jun 2004 17:43, "John Hardin" wrote:

All:

The syntax for overloading the "+" and other simple binary math operators
is pretty straightforward, but I can't seem to wrap my brain around the
idea that overloading the "+" operator simultaneously overloads the "+="
operator.

Here's the problem I'm having with it:

When you overload a binary operator like "+", you accept two arguments and
you return a new object that holds the result. That's straightforward.

But if the overload of the "+" operator returns a *new* object, how can
that same overload be used to implement the "+=" operator, which is a
change to an *existing* object?

I just can't see how you can overload "+" and "+=" with the same code. Can
somebody help me understand this by pointing me to where this is
explained, or by explaining it to me?

Because '+=' is syntactic sugar: in other words is something that the
compiler takes in and translates to something else (just like properties)
before before spitting out the appropriate MSIL. If you write 'i += j'
what the compiler actually compiles is 'i = i + j' and thus the + operator
is on it's own. IIRC '++' does the same (I think...)

--
Simon Smith
simon dot s at ghytred dot com
www.ghytred.com/NewsLook - NNTP Client for Outlook

[John Wood]

x++ and x+=1 and x=x+1 do amount to the same thing when compiled.

IL_000c: ldloc.0
IL_000d: ldc.i4.1
IL_000e: add
IL_000f: stloc.0

Each of those operations compile to exactly the same IL as seen above.

--
John Wood
EMail: first name, dot, second name at priorganize.com
"Simon Smith" <gh*****@community.nospam> wrote in message
news:44******************************@ghytred.com. ..

On 27 Jun 2004 17:43, "John Hardin" wrote:

All:

The syntax for overloading the "+" and other simple binary math operators
is pretty straightforward, but I can't seem to wrap my brain around the
idea that overloading the "+" operator simultaneously overloads the "+="
operator.

Here's the problem I'm having with it:

When you overload a binary operator like "+", you accept two arguments andyou return a new object that holds the result. That's straightforward.

But if the overload of the "+" operator returns a *new* object, how can
that same overload be used to implement the "+=" operator, which is a
change to an *existing* object?

I just can't see how you can overload "+" and "+=" with the same code. Cansomebody help me understand this by pointing me to where this is
explained, or by explaining it to me?

Because '+=' is syntactic sugar: in other words is something that the
compiler takes in and translates to something else (just like properties)
before before spitting out the appropriate MSIL. If you write 'i += j'
what the compiler actually compiles is 'i = i + j' and thus the + operator
is on it's own. IIRC '++' does the same (I think...)

--
Simon Smith
simon dot s at ghytred dot com
www.ghytred.com/NewsLook - NNTP Client for Outlook

[John Hardin]

Simon Smith sez:

On 27 Jun 2004 17:43, "John Hardin" wrote:

I just can't see how you can overload "+" and "+=" with the same code.
Can somebody help me understand this by pointing me to where this is
explained, or by explaining it to me?

Because '+=' is syntactic sugar: in other words is something that the
compiler takes in and translates to something else (just like
properties) before before spitting out the appropriate MSIL. If you
write 'i += j' what the compiler actually compiles is 'i = i + j' and
thus the + operator is on it's own.

Thanks everybody who responded. It makes sense now.

Ouch. That means you have to be really careful overloading operators for
complex classes, and have to think carefully about precisely *what* you
mean by "+" and "+=" when designing classes.

For example, if you have a class with a single numeric property and
several non-numeric properties, you would need to copy all the non-numeric
properties to your new class in the overloaded "+" code lest they get
discarded - you can't distinguish between "a = a + b" and "a = b + c" at
runtime, can you?

Maybe operator overloading is just a Bad Idea for nontrivial classes...

--
John Hardin KA7OHZ ICQ#15735746 http://www.impsec.org/~jhardin/
jh*****@impsec.org FALaholic #11174 pgpk -a jh*****@impsec.org
key: 0xB8732E79 - 2D8C 34F4 6411 F507 136C AF76 D822 E6E6 B873 2E79

[cody]

> x++ and x+=1 and x=x+1 do amount to the same thing when compiled.

IL_000c: ldloc.0
IL_000d: ldc.i4.1
IL_000e: add
IL_000f: stloc.0

Each of those operations compile to exactly the same IL as seen above.

That has nothing to do with it. The operator+ for primitive types is a
single opcode in IL (add), and for user-defined types it is a call to a
method called op_Addition(x, y).

--
cody

Freeware Tools, Games and Humour
http://www.deutronium.de.vu || http://www.deutronium.tk

[cody]

> When you overload a binary operator like "+", you accept two arguments and

you return a new object that holds the result. That's straightforward.

But if the overload of the "+" operator returns a *new* object, how can
that same overload be used to implement the "+=" operator, which is a
change to an *existing* object?

The operator overloading in .NET seems very unready. Indeed, what you want
is currently not possible.
It is the same reason why the class StringBuilder does't support operator+=,
but the class string does.

--
cody

Freeware Tools, Games and Humour
http://www.deutronium.de.vu || http://www.deutronium.tk

[John Wood]

"cody" <no****************@gmx.net> wrote in message
news:%2****************@TK2MSFTNGP12.phx.gbl...

x++ and x+=1 and x=x+1 do amount to the same thing when compiled.

IL_000c: ldloc.0
IL_000d: ldc.i4.1
IL_000e: add
IL_000f: stloc.0

Each of those operations compile to exactly the same IL as seen above.

That has nothing to do with it. The operator+ for primitive types is a
single opcode in IL (add), and for user-defined types it is a call to a
method called op_Addition(x, y).

Follow the thread man. The point here is that there is no difference between
the 3 addition operations above, which is what Simon was saying. Plus it's
interesting information, if you don't find it interesting don't comment!