operator overloading passed and returned arguments

Question

I see that in a lot of examples in c++ that operator overloading gets as an argument a class instance passed by reference or if it returns a class instance it returns it by reference as well. Is there any reason why people choose to pass it by reference while passing a pointer / by value will work as well ? An example :

Class MyClass
{
public:
    int m_num;
    MyClass() { m_num = 1;}
    const MyClass operator+(const MyClass& mcls)
    {
        MyClass temp;
        temp = m_num + mcls.m_num;
        return temp;
    }
}

Assume that we overload the = operator.

So taking for example the code I wrote, sending arguments to the operator+ overload function NOT by reference AND ALSO returning an instance of MyClass not by reference will work as well yet I see in a lot of examples it's passed and returned by reference and I would like to know if there's a reason behind this or it's just convention of some type or maybe a preference ?

Answer 1

If your actual question is about passing by const reference, then see Why pass by const reference instead of by value?, otherwise keep reading.

---

You shouldn't return a reference to a local variable. The local variable goes out of scope, leaving a reference to garbage. The C++ operator overloading guidelines state that operator+ shouldn't modify either operands and returns a new value from the two arguments.

const MyClass operator+(const MyClass& mcls) const
{
    MyClass temp = *this;
    temp.m_num += mcls.m_num;
    return temp;
}

For this reason, it is important you return a copy.

On the other hand, regarding operator=, you do want to return a reference because it is the copy assignment operator. For example:

  MyClass& MyClass::operator=(const MyClass &rhs) {
    // Check for self-assignment!
    if (this == &rhs)      // Same object?
      return *this;        // Yes, so skip assignment, and just return *this.

    ... // Deallocate, allocate new space, copy values...

    return *this;
  }

You want to copy rhs into *this and return a reference:

[...] to support safe and reasonable operator chaining. (Do this by returning *this.)

Answer 2

If your function were:

MyClass operator+(const MyClass *mcls) 

then the code a + b would not compile. You'd have to write a + &b which is horrible.

It is valid to have the operator as:

MyClass operator+(MyClass mcls)

This code , conceptually, creates an extra copy of mcls because it is passed by value. If this copy can actually be moved out of, or elided or otherwize optimized out, then this is a good style. Otherwise, the const MyClass & version is a good optimization (sometimes a premature one!) to avoid this potential extra copy.

Note that both of these should be const (that is, the function - not the return value) since they do not modify *this. And it is considered better style for operator+ to be a non-member function

The reason that operator+ should not return a reference is that people expect that + takes two inputs and generates a new output. If the code is c = a + b; then we expect a to remain unchanged. You have to make a new object somewhere which holds the sum, and return that. When we return by value, this is a temporary object and usually the compiler will elide it and write the results directly into c.

It is correct for operator+= to modify *this and return a reference to *this. A good way of implementing operator+ is actually to just call operator+= on the first operand (when passed by value).

Answer 3

Strictly speaking, passing by reference or by constant reference is not required: the code would work with passing by value. However, for most operators that would be inefficient, because passing by value entails copying the entire object - something you avoid when you pass by reference.

Same goes for returning a value: more often than not, you should return by value. However, there is one notable exception to this rule: all compound assignment operators need to return by reference, because they return (*this).

Using pointers instead of references is out of the question, but for a different reason: C++ requires operators to be compatible with specific signatures by type; a reference is type-compatible with a value of the corresponding type, but a pointer is incompatible. If you define an overload of an operator that takes pointers, C++ would not use your operators when working with values.