What do I often see references in operator overloading definitions ?

Question

For example, in the OGRE3D engine, I often see things like

class_name class_name :: operator + (class_name & object)

Instead of

class_name class_name :: operator + (class_name object)

Well it's not that I prefer the second form, but is there a particular reason to use a reference in the input ? Does it has special cases where it is necessary to use a reference instead of a copy-by-value ? Or is a performance matter ?

Answer 1

It's a performance issue. Passing by reference will generally be cheaper than passing by value (it's basically equivalent to passing by pointer).

On an unrelated note, you probably want the argument to operator+ to be const class_name &object.

Answer 2

So that object doesn't get copied from the original parameter. In fact, the preferred way is to pass object as const, and to make operator+ as const member operator:

class_name class_name :: operator + (const class_name& object) const;

Answer 3

Passing a reference is much faster than copying the whole instance of your class of course. Also, if there is no copy constructor defined for the class, it could be dangerous to copy it (default copy constructor will just copy pointers and the destructor will delete them for example).

When passing classes to a method or operator, the best is to always pass a reference. You can declare it const to be sure it is not modified to avoid side effects.

Answer 4

It is recommended to implement operator+ in terms of operator+=. First make a copy of the left argument, then modify it, and finally return the copy. Since you are going to copy the left argument anyway, you might just as well do it by using call by value for the left argument:

class_name operator+(class_name x, const class_name& y)
{
    return x += y;
}

In C++0x, you should enable move semantics for the result:

#include <utility>

class_name operator+(class_name x, const class_name& y)
{
    return std::move(x += y);
}

Answer 5

Besides the "usual" calling conventions for regular methods, I would note that the operators are somewhat peculiar.

The main reason to use const& instead of pass-by-value is correctness (performance comes second, at least in my mind). If your value may be polymorphic, then a copy means object slicing, which is undefined behavior in general.

Therefore, if you use pass-by-value, you clearly state to your caller that the object will be copied and it should not be polymorphic.

Another reason can be performance. If the class is small and its copy-constructor trivial, it might be faster to copy it than to use indirection (think of an int-like class). There are other cases where pass-by-value can be faster, but in non-inline cases they are rarer.

I do think however that none of these is the real reason and the developers just picked this out of the blue...

... because the real WTF (as they say) is that the operator@ should be declared as free functions to allow argument promotion of the left-hand side argument ...

So if they didn't follow this rule, why would they bother with usual argument passing style ?