When to return a reference and when to return a copy?

Question

I was looking at the d3dx math .h and noticed that a difference between the "+" and "+=" operators:

D3DXVECTOR3& operator += ( CONST D3DXVECTOR3& );
D3DXVECTOR3 operator + ( CONST D3DXVECTOR3& ) const;

Why is it returning a reference in the case of a += operation and a copy in the case of + operation ?

I'm guessing in the first case it's modifying the vector on which you call the += operation, something like this:

this->_x += x;
...
return *this;

and in the case of a + operation it would be doing something like this:

return D3DXVECTOR3(this->_x + x, this->_y + y, this->_z + z);

That being said, if that's what happens in the D3DXVECTOR3 implementation, why not return a reference in the case of + operation ?

Answer 1

You return a reference to the original vector in a += because you are modifying the actual vector itself and the vector will not fall out of scope.

While in a + you do not want any modification of the original vector. Instead a + operator computes a new value and uses copy constructors to return the value.

If you would try something like

D3DXVECTOR3 newVal = D3DXVECTOR3(this->_x + x, this->_y + y, this->_z + z);
return &newVal;

You would return a reference to a vector which fell out of scope and therefore will be cleaned up very soon.

Answer 2

Why is a reference returned for += ?

A reference is returned because the object is (likely) being modified directly, and as such it wouldn't make sense to create a copy for the sole purpose of returning one.

Note that the reference can still be converted to a copy by other operations (such as =):

D3DXVECTOR3 a (1,2,3);
D3DXVECTOR3 b (1,2,3);
a+=b;                 //no copy made
D3DXVECTOR3 c = a+=b; //one copy made

So this approach (returning by reference) allows for the least amount of work to be done in each situation.

Why is a reference NOT returned for + ?

A reference is not returned for + because a copy is made as part of the operation, so it's returned. Consider what would happen if you added two D3DXVECTOR3's together, like this: (a + b). Which of the two objects should the result be referencing? Well obviously the answer is neither - the result should be a copy. Hence a copy is returned.

Answer 3

In the operator += case, the method is probably modifying the calling object in place. On the other hand, operator + is creating a new D3DXVECTOR3 that is the sum of the calling object and the argument.