In computer programming, operator overloading (less commonly known as ad-hoc polymorphism) is a specific case of polymorphism in which some or all of operators like +, = or == are treated as polymorphic functions and as such have different behaviours depending on the types of its arguments. Operators need not always be symbols.

Operator overloading is usually only syntactic sugar. It can easily be emulated using function calls:

a + b × c

In a language that supports operator overloading is effectively a more concise way of writing:

operator_add (a, operator_multiply (b,c))

(Assuming the × operator has higher precedence than +.)

Operator overloading provides more than an aesthetic benefit when the language allows operators to be invoked implicitly in some circumstances. For example, this is the case with to_s operator in Ruby, which returns a string representation of an object.

Criticisms

Operator overloading has been criticised because it allows programmers to give operators completely different functionality depending on the types of their operands. C++'s usage of the << operator is an example of this problem. The expression

a << 1

will return twice the value of a if a is an integer variable, but if a is an output stream instead this will write "1" to it. Because operator overloading allows the programmer to change the usual semantics of an operator, it is usually considered good practice to use operator overloading with care.

Catalog

Languages that support operator overloading and declaring new operators:

• ALGOL 68
• Fortran (introduced in Fortran 90)
• Haskell
• PostgreSQL's dialect of SQL
• Prolog
• Ruby
• Smalltalk

Languages that support operator overloading:

• Ada
• C++
• C#
• D
• Perl
• Pico (in a way)
• Python

Languages that do not support operator overloading:

• C
• Delphi
• Pascal
• Visual Basic
• Java (though it gives special meaning to + in some contexts)