为什么在重载 = 运算符时按引用返回？

Question

I know there's plenty of questions on this already, so please bear with me on this one.

So I found this question, and I had a doubt about a modification of this.

class Blah {
public:
    Blah();
    Blah(int x, int y);
    int x;
    int y;
    Blah operator =(Blah rhs);
};
Blah::Blah() {}
Blah::Blah(int xp, int yp) {
    x = xp;
    y = yp;
}
Blah Blah::operator =(Blah rhs) {
    x = rhs.x;
    y = rhs.y;
    return *this;
}
int main() {

    Blah b1(2, 3);
    Blah b2(4, 1);
    Blah b3(8, 9);
    Blah b4(7, 5);
    b3 = b4 = b2 = b1;
    cout << b3.x << ", " << b3.y << endl;
    cout << b4.x << ", " << b4.y << endl;
    cout << b2.x << ", " << b2.y << endl;
    cout << b1.x << ", " << b1.y << endl;
    return 0;
}

So I haven't used return by reference here, while overloading the = operator, and I still get the expected output.

Why should I return by reference? The only difference I see is that copy constructor is called while returning by value but no copy constructor is called while returning by reference.

Could someone please dumb things down for me and explain the concept/idea behind returning by reference? It was taught in my class around almost a year ago, and I still don't understand it.

Answer 1

There is no strict right and wrong here. You can do weird things with operator overloads and sometimes it is appropriate. However, there is rarely a good reason to return a new instance from operator= .

The return value is to enable chaining. Your test for chaining is incomplete. Your line:

b3 = b4 = b2 = b1;

is the same as

b3 = (b4 = (b2 = b1));

And you see expected output for this case. However, chaining like this

(b3 = b4) = b1;

is expected to first assign b4 to b3 then assign b1 to b3 . Or you might want to call a method on the returned reference:

(b3 = b4).foo();

As you return a copy, the second assignment will be to a temporary and the member function foo will be called on a temporary, not on b3 as expected. To see this in action consider the output of this

int main() {

    Blah b1(2, 3);
    Blah b2(4, 1);
    Blah b3(8, 9);
    Blah b4(7, 5);        
    (b3 = b4) = b1;
    cout << b3.x << ", " << b3.y << endl;
    cout << b1.x << ", " << b1.y << endl;
    return 0;
}

when returning a copy:

7, 5
2, 3

and when returning a reference:

2, 3
2, 3

The much simpler reason is that you do not want to return a copy when there is no need to make a copy.

Answer 2

Why return by reference while overloading = operator?

Because:

• Copying is sometimes expensive, in which case it is good to avoid.
• It is conventional. That is also how the built in assignment operators of fundamental types, compiler generated assignment operators of classes, and all the assignment operators of standard types (as far as I know) work.

---

Given that the special member functions that you've defined don't do anything special, I recommend following class definition instead:

struct Blah {
    int x;
    int y;
};