What are the advantages of operator overloading in C plus plus?

Answer 1

You pass parameters by value when you do not want the original value to change. Passing by value creates a temporary copy of the value, only the copy is affected, but it can add some overhead to the function call, especially if the value is a complex structure or object. If you want any changes reflected in the original value, you must pass by reference instead.

However, if the parameter is a constant reference, the object's immutable members are not altered. So when the option exists to pass by value or by constant reference, choose constant reference every time. Pass by non-constant reference only when you expect any changes to be reflected in the original value, otherwise pass by value.

Answer 2

Primarily, the advantage is to exploit the intuition of the user. After all, there is no point whatsoever in providing an operator overload if it cannot be used intuitively.

For instance, when you increment a pointer, you expect the pointer's address to increment by sizeof(*p), not sizeof(p). That is, your intuition tells you it must increment by the size of the type being pointed at (*p), not by the size of the pointer itself (p). Were it to return the latter, it would far from intuitive and would be ultimately useless to the user -- the programmer. Thus when overloading operators you must keep this principal foremost in your mind. If the result of an operation cannot be regarded as being intuitive, it is better to simply not provide one.

As another example, the addition or plus operator (+) is intuitively used to provide the sum of two numeric objects. But it can also be used to return the sum of two strings (appending the r-value to the l-value to return a new string). This has become so intuitive to programmers that they do not question why they cannot also subtract, multiply or divide strings. It is simply because these are non-intuitive operations when applied to strings. Again, keep this in mind when tempted to provide arithmetic operators to your objects. If they contain mixed data (numeric values, strings and other complex objects), then you would not expect to perform arithmetic at all, so leave them out. If the objects contain purely numeric data, then arithmetic could be considered intuitive in some cases, but certainly not all cases. If in doubt, leave it out.

Most of the time the only operators you really need to overload are the assignment operator (=) and the relational operators (==, !=, <, <=, > and >=), thus allowing users to compare objects intuitively. Indeed, when sorting objects you're really only interested in the less-than operator, but if you provide one relational operator then you are always expected to provide them all, because users will intuitively expect them all.

Keep in mind that any operation can be handled by a named function instead. Indeed, most operations should simply delegate their implementation to an equivalent function. Named functions are not as intuitive as operators, but they are more explicit -- assuming the name is self-explanatory. And if you cannot provide an intuitive operator, then a named function is a much safer option. For instance, string objects typically support the compound += operator and an append method. Both do exactly the same thing and while append is explicit and self explanatory, the += operator is more intuitive. Thus the += operator simply invokes the append method. Moreover, the += operator can be inline expanded to remove the otherwise unnecessary function call.