return value of operator overloading in C++

up vote 25 down vote favorite 8

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. c++  operator-overloading share improve this question edited Feb 25 '10 at 20:22 Tyler McHenry 39.8k 5 79 135 asked  Feb 25 '10 at 20:05 skydoor 6,740 17 86 145

add a comment

5 Answers

active oldest votes

up vote 33 down vote accepted

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). share improve this answer edited Mar 3 '10 at 19:14 answered  Feb 25 '10 at 20:08 Tyler McHenry 39.8k 5 79 135

6   Which goes hand in hand with "if it's const, return a value, if it's non-const, return a reference". –   GManNickG Feb 25 '10 at 20:11 6   Technically << does not modify the existing value. It's just a left-shift operator. It's the stream interface breaking the rules. –   kennytm  Feb 25 '10 at 20:13 @GMan correct, although that doesn't cover the cases (such as operator<<) where the overload is implemented as a non-member. –   Tyler McHenry  Feb 25 '10 at 20:13 1   The "produces a new value" is a little imprecise. ++ produces a new value, after all. How about keep the second half of the sentence, and add "All other values should return by value." –   thebretness  Feb 25 '10 at 20:14 2   @KennyTM I had no idea old C codgers were still putting up that fight after so many years. :) –  Tyler McHenry  Feb 25 '10 at 20:17 show 10 more comments

up vote 12 down vote

To attempt an answer to your question regarding strings, the operator+() for strings is almost always implemented as a free (non-member) function so that implicit conversions can be performed on either parameter. That is so you can say things like: string s1 = "bar"; string s2 = "foo" + s1; Given that, and that we can see that neither parameter can be changed, it must be declared as: RETURN_TYPE operator +( const string & a, const string & b ); We ignore the RETURN_TYPE for the moment. As we cannot return either parameter (because we can't change them), the implementation must create a new, concatenated value: RETURN_TYPE operator +( const string & a, const string & b ) { string newval = a; newval += b; // a common implementation return newval; } Now if we make RETURN_TYPE a reference, we will be returning a reference to a local object, which is a well-known no-no as the local object don't exist outside the function. So our only choice is to return a value, i.e. a copy: string operator +( const string & a, const string & b ) { string newval = a; newval += b; // a common implementation return newval; } share improve this answer answered  Feb 25 '10 at 20:29 anon

So, for freeing the allocated result, am I correct that because the invocation of the Operator is in effect a declaration, the anonymous return value goes on the stack, and so is freed when the containing function returns? –   no comprende  Jul 14 at 14:51 add a comment

up vote 3 down vote

If you want your operator overload to behave like the built-in operator, then the rule is pretty simple; the standard defines exactly how the built-in operators behave and will indicate if the result of a built-in is an rvalue or an lvalue. The rule you should use is: if the built-in operator returns an rvalue then your overload should return a reference if the built-in returns an lvalue then your overload should return a value However, your overload isn't required to return the same kind of result as the built-in, though that's what you should do unless you have a good reason to do otherwise. For example, KennyTM noted in a comment to another answer that the stream overloads for the <<and >> operators return a reference to the left operand, which is not how the built-ins work. But the designers of the stream interface did this so stream I/O could be chained. share improve this answer answered  Feb 25 '10 at 20:26 Michael Burr 208k 26 300 526

For reference the built-in operators are in § 13.6 of the N3337 draft C++11 standard, which is the only version of the standard I have at hand. –   Mark Ransom  Jul 27 '12 at 17:25 add a comment

up vote 2 down vote	Depending on the operator you may have to return by value. When both can be used though, like in operator+= you could consider the following: If your objects are immutable it's probably better to return by value. If your objects are mutable it's probably better to return by reference. share improve this answer answered  Feb 25 '10 at 20:08 Brian R. Bondy 166k 70 420 540
	add a comment

up vote 0 down vote

Usually you return by reference in an operation that changes the value of the things it's operating on, like = or +=. All other operations are return by value. This is more a rule of thumb, though. You can design your operator either way. share improve this answer edited Feb 25 '10 at 20:10 answered  Feb 25 '10 at 20:09 thebretness 445 2 11