Returned value with operator overloaded function???

There are binary operators and unary operators. I am a little confused about the parameters and the return value of operators. For instance "+" takes two arguments right? The left operand and the right operand and the value returned is usually assigned to a variable. Hmm this makes a little sense but what about the "+=" operator. This takes two arguments also? Where does the return value go?

An example from the book I'm reading.

Code:

---


class String {
        friend const String &operator+=( String &, const String & );

---

The += operator is being overloaded to concatenate two strings. The operand on the left is going to be modified so I understand why its declared const but I don't understand why the function is returning a const reference to a string. Where does the return value go anyway?

The constant reference IS the return value. The reference so it doesn't have to be copied, and the const so the compiler can make optimizations (and disallow modifications of the reference).

string2 += string1;

isn't string2 the left operand and string1 the right operand? If so where does the return value go?

string2 is the first argument, string1 is the second. In your example (string2 += string1) you don't use the return value, but imagine a statement like this:

string3 = string2 += string1

stirng3 gets the return value. Confusing to read perhaps, but valid code. A more useful case would be the return value of the normal assignment, so you can nest like this:

var1 = var2 = var3 = 4

I never use that, but it's probably common for some poeple.

Magos,

String3 is constant and string2 is not but they have the same value correct? What good reasons are there for having a constant return value for the function? What exactly is constant by the way? If the string was declared constant then it would not be possible to assign a value to it so what exactly is constant?

I haven't metioned anything about constants. Of course you cannot assign anything to a constant variable. The compiler (assumin it's a decent one) should complain about that. The reason an assignment should return the assigned value is cause the standard says so. Some smart guy(s) thought that out. The reasoning behind that I don't know, but it's probably so you can nest assignments (a = b = c) or use this kind of if statements:

if((a = new int) == NULL)

I never use nested assignments, I thnk it's too cluttered, especially when operations are performed too (+=,-= etc). It's a personal preference.

EDIT: Oh, right. The reason the return value is constant is cause it's a reference. The reference is there so you don't have to copy the data, which would be more time consuming than simply passing a reference (kind of a pointer) to it. The const is there so you're not allowed to modify what is returned. It wouldn't be so good if you type a = b, then a can modify b through the return value from b. Note that a does NOT have to be a constant variable. You can always assign a normal variable the value of a constant variable.

I'm not sure I understand. After a = b, a points to the same value as b but what exactly is constant, the reference itself or the value the reference references?

Quote:

---

string3 = string2 += string1

---

Using the example Magos provided... the returned value of the += operation (the new combined string) is the constant and is essentially a temporary in this sense. As soon as the value is returned, it is then used to initialize the string3 variable (by way of either the assignment operator or copy constructor).

The returned value is defined to be a constant because there shouldn't be any real reason to need to modify it. In the above case, the constant returned value is used to then initialize string3 so we aren't modifying the returned value, simply using it to immediately initialize another variable.

My understanding is getting a little better but even if the value returned by the concatenation operator is not constant I don't see how it can be modified through string3. String3 itself is not constant so its value can change but if its value is a non const reference how would I change the value of that reference?

With pointers I think its easier to understand. If only the value is constant then I should still be able to modify the variable to point to something else but aren't references supposed to be initialized when they're declared?

Hmm i have a thought.

a = b

a = b is possible where a and b are references of the same type? But a = 4 is not since the assignment operator returns a constant reference? Is this how it works?