您的位置：首页 > 编程语言 > C语言/C++

return value of operator overloading in C++

2015-07-27 17:39 519 查看

up
vote25down
votefavorite
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

shareimprove
this question

edited Feb
25 '10 at 20:22

Tyler McHenry

39.8k579135

asked Feb 25 '10 at 20:05

skydoor

6,7401786145

add
a comment

5 Answers

active oldest votes

up vote33down
voteaccepted

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

<<

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).

shareimprove
this answer

edited Mar
3 '10 at 19:14

answered Feb 25 '10 at 20:08

Tyler McHenry

39.8k579135

Which goes hand in hand with "if it's const, return a value, if it's non-const, return a reference". – GManNickGFeb
25 '10 at 20:11

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

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

@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 vote12down
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;
}

shareimprove
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 vote3down
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.

shareimprove
this answer

answered Feb 25 '10 at 20:26

Michael Burr

208k26300526

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 vote2down
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.

shareimprove
this answer

answered Feb 25 '10 at 20:08