return value of operator overloading in C++
c++, operator-overloading
Solution
Some operators return by value, some by reference. In general, an operator whose result is a new value (such as +, -, etc) must return the new value by value, and an operator whose result is an existing value, but modified (such as <<, >>, +=, -=, etc), should return a reference to the modified value.
For example, `cout` is a `std::ostream`, and inserting data into the stream is a modifying operation, so to implement the `<<` operator to insert into an `ostream`, the operator is defined like this:
std::ostream& operator<< (std::ostream& lhs, const MyType& rhs)
{
// Do whatever to put the contents of the rhs object into the lhs stream
return lhs;
}
This way, when you have a compound statement like `cout << x << y`, the sub-expression `cout << x` is evaluated first, and then the expression `[result of cout << x ] << y` is evaluated. Since the operator `<<` on `x` returns a reference to `cout`, the expression `[result of cout << x ] << y` is equivalent to `cout << y`, as expected.
Conversely, for "string + string", the result is a new string (both original strings are unchanged), so it must return by value (otherwise you would be returning a reference to a temporary, which is undefined behavior).
Problem
I have a question about the return value of operator overloading in C++. Generally, I found two cases, one is return-by-value, and one is return-by-reference. So what's the underneath rule of that? Especially at the case when you can use the operator continuously, such as `cout<<x<<y`. For example, when implementing a + operation "string + (string)". how would you return the return value, by ref or by val.