In computer programming, operator overloading, sometimes termed operator ad hoc polymorphism, is a specific case of polymorphism, where different operators have different implementations depending on their arguments. Operator overloading is generally defined by a programming language, a programmer, or both.

## Rationale

Operator overloading is syntactic sugar, and is used because it allows programming using notation nearer to the target domain[1] and allows user-defined types a similar level of syntactic support as types built into a language. It is common, for example, in scientific computing, where it allows computing representations of mathematical objects to be manipulated with the same syntax as on paper.

Operator overloading does not change the expressive power of a language (with functions), as it can be emulated using function calls. For example, consider variables `a`, `b` and `c` of some user-defined type, such as matrices:

`a + b * c`

In a language that supports operator overloading, and with the usual assumption that the '*' operator has higher precedence than the '+' operator, this is a concise way of writing:

`Add(a, Multiply(b, c))`

However, the former syntax reflects common mathematical usage.

## Examples

In this case, the addition operator is overloaded to allow addition on a user-defined type `Time` in C++:

```Time operator+(const Time& lhs, const Time& rhs) {
Time temp = lhs;
temp.seconds += rhs.seconds;
temp.minutes += temp.seconds / 60;
temp.seconds %= 60;
temp.minutes += rhs.minutes;
temp.hours += temp.minutes / 60;
temp.minutes %= 60;
temp.hours += rhs.hours;
return temp;
}
```

Addition is a binary operation, which means it has two operands. In C++, the arguments being passed are the operands, and the `temp` object is the returned value.

The operation could also be defined as a class method, replacing `lhs` by the hidden `this` argument; However, this forces the left operand to be of type `Time`:

```// The "const" right before the opening curly brace means that |this| is not modified.
Time Time::operator+(const Time& rhs) const {
Time temp = *this;  // |this| should not be modified, so make a copy.
temp.seconds += rhs.seconds;
temp.minutes += temp.seconds / 60;
temp.seconds %= 60;
temp.minutes += rhs.minutes;
temp.hours += temp.minutes / 60;
temp.minutes %= 60;
temp.hours += rhs.hours;
return temp;
}
```

Note that a unary operator defined as a class method would receive no apparent argument (it only works from `this`):

```bool Time::operator!() const {
return hours == 0 && minutes == 0 && seconds == 0;
}
```

The less-than (<) operator is often overloaded to sort a structure or class:

```class Pair {
public:
bool operator<(const Pair& p) const {
if (x_ == p.x_) {
return y_ < p.y_;
}
return x_ < p.x_;
}

private:
int x_;
int y_;
};
```

Like with the previous examples, in the last example operator overloading is done within the class. In C++, after overloading the less-than operator (<), standard sorting functions can be used to sort some classes.

## Criticisms

Operator overloading has often been criticized[2] because it allows programmers to reassign the semantics of operators depending on the types of their operands. For example, the use of the `<<` operator in C++ `a << b` shifts the bits in the variable `a` left by `b` bits if `a` and `b` are of an integer type, but if `a` is an output stream then the above code will attempt to write a `b` to the stream. Because operator overloading allows the original programmer to change the usual semantics of an operator and to catch any subsequent programmers by surprise, it is considered good practice to use operator overloading with care (the creators of Java decided not to use this feature,[3] although not necessarily for this reason).

Another, more subtle, issue with operators is that certain rules from mathematics can be wrongly expected or unintentionally assumed. For example, the commutativity of + (i.e. that `a + b == b + a`) does not always apply; an example of this occurs when the operands are strings, since + is commonly overloaded to perform a concatenation of strings (i.e. `"bird" + "song"` yields `"birdsong"`, while `"song" + "bird"` yields `"songbird"`). A typical counter[citation needed] to this argument comes directly from mathematics: While + is commutative on integers (and more generally any complex number), it is not commutative for other "types" of variables. In practice, + is not even always associative, for example with floating-point values due to rounding errors. Another example: In mathematics, multiplication is commutative for real and complex numbers but not commutative in matrix multiplication.

## Catalog

A classification of some common programming languages is made according to whether their operators are overloadable by the programmer and whether the operators are limited to a predefined set.

New definable[4]
Limited set

### 1960s

Extract from the ALGOL 68 language specification (page 177) where the overloaded operators ¬, =, ≠, and abs are defined:

```10.2.2. Operations on Boolean Operands
a) op ∨ = (bool a, b) bool:( a | true | b );
b) op ∧ = (bool a, b) bool: ( a | b | false );
c) op ¬ = (bool a) bool: ( a | false | true );
d) op = = (bool a, b) bool:( a∧b ) ∨ ( ¬b∧¬a );
e) op ≠ = (bool a, b) bool: ¬(a=b);
f) op abs = (bool a)int: ( a | 1 | 0 );
```

Note that no special declaration is needed to overload an operator, and the programmer is free to create new operators.

### 1980s

Ada supports overloading of operators from its inception, with the publication of the Ada 83 language standard. However, the language designers chose to preclude the definition of new operators. Only extant operators in the language may be overloaded, by defining new functions with identifiers such as "+", "*", "&" etc. Subsequent revisions of the language (in 1995 and 2005) maintain the restriction to overloading of extant operators.

### 1990s

Lua allows operator overloading as syntactic sugar for method calls with the added feature that if the first operand doesn't define that operator, the method for the second operand will be used.

### 2000s

Scala treats all operators as methods and thus allows operator overloading by proxy.

In Raku, the definition of all operators is delegated to lexical functions, and so, using function definitions, operators can be overloaded or new operators added. For example, the function defined in the Rakudo source for incrementing a Date object with "+" is:

```multi infix:<+>(Date:D \$d, Int:D \$x) {
Date.new-from-daycount(\$d.daycount + \$x)
}
```

Since "multi" was used, the function gets added to the list of multidispatch candidates, and "+" is only overloaded for the case where the type constraints in the function signature are met. While the capacity for overloading includes +, *, >=, the postfix and term i, and so on, it also allows for overloading various brace operators: "[x, y]", "x[ y ]", "x{ y }", and "x( y )".

## References

1. ^ Stroustrup, Bjarne. "Operator Overloading". C++ FAQ. Archived from the original on 14 August 2011. Retrieved 27 August 2020.
3. ^ "No more operator overloading". The Java Language Environment. Oracle Corporation.
4. ^ Completely new operators can be added.
5. ^ Binary functions with a symbolic name can be called infix.
6. ^
7. ^ Hunt, John (6 December 2012). Smalltalk and Object Orientation: An Introduction. Springer Science & Business Media. ISBN 978-1-4471-0961-7.
8. ^ "Bertrand Meyer: Basic Eiffel language mechanisms". se.ethz.ch. Retrieved 7 April 2021.
9. ^ "Operator functions in F90". www.mathcs.emory.edu. Retrieved 7 April 2021.`{{cite web}}`: CS1 maint: url-status (link)
10. ^ Introduced in Fortran 90.
11. ^ "3. Language Reference — Futhark 0.19.0 documentation". futhark.readthedocs.io. Retrieved 10 October 2020.
12. ^ Smith, Chris (9 October 2012). Programming F# 3.0: A Comprehensive Guide for Writing Simple Code to Solve Complex Problems. O'Reilly Media, Inc. ISBN 978-1-4493-2604-3.
14. ^ "io guide". iolanguage.org. Retrieved 7 April 2021.
15. ^
16. ^ "Operators - R in a Nutshell, 2nd Edition [Book]". www.oreilly.com. Retrieved 7 April 2021.
17. ^
18. ^ "Operators". Tour of Scala.
19. ^ "Seed7 Manual: Structured syntax definition". seed7.sourceforge.net. Retrieved 29 September 2020.
20. ^
21. ^ "Why does Go not support overloading of methods and operators?". Retrieved 4 September 2011.
22. ^ "Introduction". freepascal.org. Retrieved 30 September 2020.
23. ^ "Operator Overloads". Retrieved 28 September 2018.
25. ^ Drayton, Peter; Albahari, Ben; Neward, Ted (2003). C# in a Nutshell. O'Reilly Media, Inc. ISBN 978-0-596-00526-9.
26. ^
27. ^ "Eclipse Ceylon: Operator Polymorphism". ceylon-lang.org. Retrieved 7 April 2021.
28. ^ "Operator Overloading - D Programming Language". dlang.org. Retrieved 10 October 2020.
29. ^ "A tour of the Dart language". dart.dev. Retrieved 30 September 2020.
31. ^ "The Apache Groovy programming language - Operators". groovy-lang.org. Retrieved 30 September 2020.
34. ^ "Metamethods Tutorial". Lua-users Wiki.
35. ^ "Implementing Operators for Your Class". Retrieved 1 October 2013.