Operator overloading
|
|
nl:operator-overloadingpl:przeciążanie operatorówzh-cn:运算符重载 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.
Gutter Talk
Additionally, many programmers fail to make the distinction between operator overloading and operator overriding. To say a class T exposes two = overrides would make it valid to say that = is overloaded, because the signature for each method differs in its arguments. But to say that class T exposes one = override does not make it valid to say = is overloaded, because it make not actually differ in signature from the base implementation. Because of this there is often confusion between operator overrides and operator overloads, and most developers blur any distinction and refer to both as operator overloads, which is semantically incorrect. It's the programmer equivalent of gutter speak, things spoken without considering their true meaning.
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:
Languages that do not support operator overloading:
- C
- Delphi
- Pascal
- Visual Basic
- Java (though it gives special meaning to + in some contexts)