Operator overloading: Difference between revisions
m Task 70: Update syntaxhighlight tags - remove use of deprecated <source> tags |
No edit summary |
||
(36 intermediate revisions by 27 users not shown) | |||
Line 1: | Line 1: | ||
{{Short description|Feature of some programming languages}} |
{{Short description|Feature of some programming languages}} |
||
{{Use American English|date = March 2019}} |
{{Use American English|date = March 2019}} |
||
⚫ | |||
{{Polymorphism}} |
{{Polymorphism}} |
||
In [[computer programming]], '''operator overloading''', sometimes termed ''operator [[ad hoc polymorphism]]'', is a specific case of [[polymorphism (computer science)|polymorphism]], where different [[ |
In [[computer programming]], '''operator overloading''', sometimes termed ''operator [[ad hoc polymorphism]]'', is a specific case of [[polymorphism (computer science)|polymorphism]], where different [[Operator (computer programming)|operators]] have different implementations depending on their arguments. Operator overloading is generally defined by a [[programming language]], a [[programmer]], or both. |
||
==Motive== |
==Rationale {{Anchor|Motive}}== |
||
Operator overloading is [[syntactic sugar]], and is used because it allows programming using notation nearer to the target domain<ref>{{cite web | |
Operator overloading is [[syntactic sugar]], and is used because it allows programming using notation nearer to the target domain<ref>{{cite web |website=C++ FAQ |title=Operator Overloading |url=https://isocpp.org/wiki/faq/operator-overloading#op-ov-benefits |last=Stroustrup |first=Bjarne |author-link=Bjarne Stroustrup |access-date=27 August 2020 |archive-url=https://web.archive.org/web/20110814105309/http://www.parashift.com/c++-faq-lite/operator-overloading.html#faq-13.2 |archive-date=14 August 2011}}</ref> 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 [[ |
Operator overloading does not change the [[Expressive power (computer science)|expressive power]] of a language (with functions), as it can be emulated using function calls. For example, consider variables {{code|a}}, {{code|b}} and {{code|c}} of some user-defined type, such as [[Matrix (mathematics)|matrices]]: |
||
{{code|a + b * c}} |
|||
In a language that supports operator overloading, and with the usual assumption that the '*' operator has higher [[ |
In a language that supports operator overloading, and with the usual assumption that the '*' operator has higher [[Order of operations|precedence]] than the '+' operator, this is a concise way of writing: |
||
{{code|Add(a, Multiply(b, c))}} |
|||
However, the former syntax reflects common mathematical usage. |
However, the former syntax reflects common mathematical usage. |
||
==Examples== |
==Examples== |
||
In this case, the addition operator is overloaded to allow addition on a user-defined type |
In this case, the addition operator is overloaded to allow addition on a user-defined type {{code|Time}} in [[C++]]: |
||
<syntaxhighlight lang=Cpp> |
<syntaxhighlight lang=Cpp> |
||
Line 34: | Line 35: | ||
</syntaxhighlight> |
</syntaxhighlight> |
||
Addition is a [[binary operation]], which means it has two [[ |
Addition is a [[binary operation]], which means it has two [[operand]]s. In C++, the arguments being passed are the operands, and the {{code|temp}} object is the returned value. |
||
The operation could also be defined as a class method, replacing |
The operation could also be defined as a class method, replacing {{code|lhs}} by the hidden {{code|this}} argument; However, this forces the left operand to be of type {{code|Time}}: |
||
<syntaxhighlight lang=Cpp> |
<syntaxhighlight lang=Cpp> |
||
// |
// The "const" right before the opening curly brace means that |this| is not modified. |
||
// \ |
|||
// ------------------------------------\ |
|||
// | |
|||
// V |
|||
Time Time::operator+(const Time& rhs) const { |
Time Time::operator+(const Time& rhs) const { |
||
Time temp = *this; // |
Time temp = *this; // |this| should not be modified, so make a copy. |
||
temp.seconds += rhs.seconds; |
temp.seconds += rhs.seconds; |
||
temp.minutes += temp.seconds / 60; |
temp.minutes += temp.seconds / 60; |
||
Line 57: | Line 54: | ||
</syntaxhighlight> |
</syntaxhighlight> |
||
Note that a [[ |
Note that a [[Unary operation|unary]] operator defined as a class method would receive no apparent argument (it only works from {{code|this}}): |
||
<syntaxhighlight lang=Cpp> |
<syntaxhighlight lang=Cpp> |
||
Line 65: | Line 62: | ||
</syntaxhighlight> |
</syntaxhighlight> |
||
The less-than (<) operator is often overloaded to sort a structure or class: |
|||
<syntaxhighlight lang=Cpp> |
<syntaxhighlight lang=Cpp> |
||
class Pair { |
class Pair { |
||
Line 81: | Line 79: | ||
}; |
}; |
||
</syntaxhighlight> |
</syntaxhighlight> |
||
Like with the previous examples, in the last example operator overloading is done within the class. In C++, after overloading the less-than operator (<), [[sort (C++)|standard sorting functions]] can be used to sort some classes. |
|||
==Criticisms== |
==Criticisms== |
||
Operator overloading has often been criticized<ref> |
Operator overloading has often been criticized<ref>{{cite web |url=http://pages.cs.wisc.edu/~fischer/cs538.s08/lectures/Lecture08.4up.pdf |title=Issues in Overloading |last=Fisher |first=Charles N. |publisher=[[University of Wisconsin–Madison]] |year=2008}}</ref> because it allows programmers to reassign the semantics of operators depending on the types of their operands. For example, the use of the {{code|<<}} operator in [[C++]] <syntaxhighlight lang=Cpp inline>a << b</syntaxhighlight> shifts the bits in the variable {{code|a}} left by {{code|b}} bits if {{code|a}} and {{code|b}} are of an integer type, but if {{code|a}} is an output stream then the above code will attempt to write a {{code|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 (programming language)|Java]] decided not to use this feature,<ref>{{cite web |url=http://www.oracle.com/technetwork/java/simple-142616.html#4098 |website=The Java Language Environment |title=No more operator overloading |publisher=[[Oracle Corporation]]}}</ref> although not necessarily for this reason). |
||
<syntaxhighlight lang=Cpp> |
|||
a << 1 |
|||
</syntaxhighlight> |
|||
shifts the bits in the variable <tt>a</tt> left by 1 bit if <tt>a</tt> is of an integer type, but if <tt>a</tt> is an output stream then the above code will attempt to write a "1" 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 (programming language)|Java]] decided not to use this feature,<ref>[http://www.oracle.com/technetwork/java/simple-142616.html#4098 No more operator overloading – Features Removed from C and C++]</ref> 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 |
Another, more subtle, issue with operators is that certain rules from mathematics can be wrongly expected or unintentionally assumed. For example, the [[Commutative property|commutativity]] of + (i.e. that {{code|1=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. {{code|"bird" + "song"}} yields {{code|"birdsong"}}, while {{code|"song" + "bird"}} yields {{code|"songbird"}}). A typical counter{{citation needed|date=September 2013}} 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 [[operator associativity|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== |
==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. |
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. |
||
{| class="wikitable" |
{| class="wikitable" |
||
|- |
|- |
||
Line 100: | Line 96: | ||
! Overloadable |
! Overloadable |
||
|- |
|- |
||
! New definable<ref>Completely new operators can be added</ref> |
! New definable<ref>Completely new operators can be added.</ref> |
||
| <!-- "Not overloadable" and "New operators definable" --> |
| <!-- "Not overloadable" and "New operators definable" --> |
||
*[[ML (programming language)|ML]] |
*[[ML (programming language)|ML]] |
||
*[[Pico (programming language)|Pico]]<ref> |
*[[Pico (programming language)|Pico]]<ref>Binary functions with a symbolic name can be called infix.</ref> |
||
*[[Prolog]]<ref>https://www.swi-prolog.org/pldoc/man?predicate=op/3</ref> |
*[[Prolog]]<ref>{{cite web |url=https://www.swi-prolog.org/pldoc/man?predicate=op/3 |title=Predicate op/3}}</ref> |
||
*[[Smalltalk]]<ref name="Hunt2012">{{cite book |last=Hunt |first=John |title=Smalltalk and Object Orientation: An Introduction |url=https://books.google.com/books?id=BiDUBwAAQBAJ&q=overloading+operators |date=6 December 2012 |publisher=Springer Science & Business Media |isbn=978-1-4471-0961-7}}</ref> |
|||
| |
|<!-- "Overloadable" and "New operators definable" --> |
||
*[[ALGOL 68#op: Operators|ALGOL 68]] |
*[[ALGOL 68#op: Operators|ALGOL 68]] |
||
*[[Clojure]] |
*[[Clojure]] |
||
*[[Eiffel (programming language)|Eiffel]]<ref>{{Cite web|title=Bertrand Meyer: Basic Eiffel language mechanisms|url=http://se.ethz.ch/~meyer/publications/online/eiffel/basic.html|access-date=2021-04-07|website=se.ethz.ch}}</ref> |
|||
*[[Eiffel (programming language)|Eiffel]] |
|||
*[[Fortran]]<ref>{{Cite web|title=Operator functions in F90|url=http://www.mathcs.emory.edu/~cheung/Courses/561/Syllabus/6-Fortran/operators.html|access-date=2021-04-07|website=www.mathcs.emory.edu}}</ref><ref>Introduced in Fortran 90.</ref> |
|||
*[[Fortran]]<ref>introduced in Fortran 90</ref> |
|||
*[[Futhark (programming language)|Futhark]]<ref>{{Cite web|title=3. Language Reference — Futhark 0.19.0 documentation|url=https://futhark.readthedocs.io/en/latest/language-reference.html|access-date=2020-10-10|website=futhark.readthedocs.io}}</ref> |
|||
*[[F Sharp (programming language)|F#]]<ref name="Smith2012">{{cite book| |
*[[F Sharp (programming language)|F#]]<ref name="Smith2012">{{cite book |last=Smith |first=Chris |title=Programming F# 3.0: A Comprehensive Guide for Writing Simple Code to Solve Complex Problems |url=https://books.google.com/books?id=e0Wl6id4unQC&q=%22operator+overloading%22 |date=9 October 2012 |publisher=O'Reilly Media, Inc. |isbn=978-1-4493-2604-3}}</ref> |
||
*[[Haskell (programming language)|Haskell]]<ref>[[type class]]es instead of overloading</ref> |
|||
*[[ |
*[[Haskell (programming language)|Haskell]]<ref>[[Type class]]es instead of overloading.</ref> |
||
*[[Io (programming language)|Io]]<ref>{{Cite web|title=io guide|url=https://iolanguage.org/guide/guide.html#Syntax-Operators|access-date=2021-04-07|website=iolanguage.org}}</ref> |
|||
*[[R (programming language)|R]] |
|||
*[[ |
*[[Nim (programming language)|Nim]]<ref>{{cite web|title=Operators|url=https://nim-lang.github.io/Nim/tut1.html#procedures-operators}}</ref> |
||
*[[ |
*[[R (programming language)|R]]<ref>{{Cite web|title=Operators - R in a Nutshell, 2nd Edition [Book]|url=https://www.oreilly.com/library/view/r-in-a/9781449358204/ch06s02.html|access-date=2021-04-07|website=www.oreilly.com|language=en}}</ref> |
||
⚫ | |||
*[[Seed7]] |
|||
*[[Scala (programming language)|Scala]]<ref>{{cite web |url=https://docs.scala-lang.org/tour/operators.html |website=Tour of Scala |title=Operators}}</ref> |
|||
*[[Smalltalk]] |
|||
*[[Seed7]]<ref>{{Cite web|title=Seed7 Manual: Structured syntax definition|url=http://seed7.sourceforge.net/manual/syntax.htm|access-date=2020-09-29|website=seed7.sourceforge.net}}</ref> |
|||
⚫ | |||
*[[Swift (programming language)|Swift]]<ref>{{cite web |url=https://docs.swift.org/swift-book/LanguageGuide/AdvancedOperators.html |title=Swift: Advanced Operators}}</ref> |
|||
|- |
|- |
||
! Limited set |
! Limited set |
||
| |
|<!-- "Not overloadable" and "Limited set of operators" --> |
||
*[[BASIC]] |
*[[BASIC]] |
||
*[[C (programming language)|C]] |
*[[C (programming language)|C]] |
||
*[[Go (programming language)|Go]]<ref>{{cite web|title=Why does Go not support overloading of methods and operators?|url=http://golang.org/doc/go_faq.html#overloading|access-date=4 September 2011}}</ref> |
*[[Go (programming language)|Go]]<ref>{{cite web |title=Why does Go not support overloading of methods and operators? |url=http://golang.org/doc/go_faq.html#overloading |access-date=4 September 2011}}</ref> |
||
*[[Java (programming language)|Java]] |
*[[Java (programming language)|Java]] |
||
*[[JavaScript]] |
*[[JavaScript]] |
||
*[[Modula-2]] |
*[[Modula-2]] |
||
*[[Objective-C]] |
*[[Objective-C]] |
||
*[[Pascal (programming language)|Pascal]] |
*[[Pascal (programming language)|Pascal]]<ref>{{Cite web|title=Introduction|url=https://www.freepascal.org/docs-html/ref/refse101.html#x213-23500015.1|access-date=2020-09-30|website=freepascal.org}}</ref> |
||
*[[TypeScript]]<ref>{{cite web|title=Operator Overloads|url=https://github.com/Microsoft/TypeScript/issues/5407|access-date=28 September 2018}}</ref> |
*[[TypeScript]]<ref>{{cite web |title=Operator Overloads |url=https://github.com/Microsoft/TypeScript/issues/5407 |access-date=28 September 2018}}</ref> |
||
⚫ | |||
⚫ | |||
| |
|<!-- "Overloadable" and "Limited set of operators" --> |
||
*[[Ada (programming language)|Ada]]<ref>https://www.adaic.org/resources/add_content/standards/05aarm/html/AA-6-6.html</ref> |
*[[Ada (programming language)|Ada]]<ref>{{cite web |url=https://www.adaic.org/resources/add_content/standards/05aarm/html/AA-6-6.html |website=Annotated Ada Reference Manual |title=6.6 Overloading of Operators}}</ref> |
||
*[[C Sharp (programming language)|C#]]<ref name="DraytonAlbahari2003">{{cite book| |
*[[C Sharp (programming language)|C#]]<ref name="DraytonAlbahari2003">{{cite book |last1=Drayton |first1=Peter |last2=Albahari |first2=Ben |last3=Neward |first3=Ted |title=C# in a Nutshell |url=https://books.google.com/books?id=bG_Aqb6iOUYC&q=%22operator+overloading%22 |year=2003 |publisher=O'Reilly Media, Inc. |isbn=978-0-596-00526-9}}</ref> |
||
*[[C++]]<ref>https://en.cppreference.com/w/cpp/language/operators</ref> |
*[[C++]]<ref>{{cite web |url=https://en.cppreference.com/w/cpp/language/operators |title=C++ Operator Overloading}}</ref> |
||
*[[Ceylon (programming language)|Ceylon]]<ref>{{Cite web|title=Eclipse Ceylon: Operator Polymorphism|url=https://ceylon-lang.org/documentation/1.3/reference/operator/operator-polymorphism/|access-date=2021-04-07|website=ceylon-lang.org}}</ref> |
|||
*[[Ceylon (programming language)|Ceylon]] |
|||
*[[D (programming language)|D]]<ref>{{Cite web|title=Operator Overloading - D Programming Language|url=https://dlang.org/spec/operatoroverloading.html|access-date=2020-10-10|website=dlang.org}}</ref> |
|||
*[[D (programming language)|D]] |
|||
*[[Dart (programming language)|Dart]]<ref>{{Cite web|title=A tour of the Dart language|url=https://dart.dev/guides/language/language-tour|access-date=2020-09-30|website=dart.dev}}</ref> |
|||
*[[Dart (programming language)|Dart]] |
|||
*[[FreeBASIC]]<ref>{{Cite web|title=Operator Overloading|url=http://bourabai.kz/einf/freebasic/ProPgOperatorOverloading.html|access-date=2021-04-07|website=bourabai.kz}}</ref> |
|||
*[[FreeBASIC]] |
|||
*[[Groovy (programming language)|Groovy]]<ref>{{Cite web|title=The Apache Groovy programming language - Operators|url=https://groovy-lang.org/operators.html#Operator-Overloading|access-date=2020-09-30|website=groovy-lang.org}}</ref> |
|||
*[[Groovy (programming language)|Groovy]] |
|||
*[[ |
*[[Java (programming language)|Java]]<ref>{{cite web |title=Operator Overloading |url=https://github.com/manifold-systems/manifold/tree/master/manifold-deps-parent/manifold-ext#operator-overloading |website=Manifold |access-date=7 June 2020}}</ref> |
||
*[[ |
*[[Kotlin (programming language)|Kotlin]]<ref>{{cite web |title=Operator overloading |url=https://kotlinlang.org/docs/reference/operator-overloading.html |website=Kotlin |access-date=24 June 2018}}</ref> |
||
*[[Lua (programming language)|Lua]]<ref>{{cite web |url=http://lua-users.org/wiki/MetamethodsTutorial |title=Metamethods Tutorial |website=Lua-users Wiki}}</ref> |
|||
*[[MATLAB]]<ref>{{cite web |title=Implementing Operators for Your Class |url=http://www.mathworks.com/help/matlab/matlab_oop/implementing-operators-for-your-class.html |access-date=1 October 2013}}</ref> |
*[[MATLAB]]<ref>{{cite web |title=Implementing Operators for Your Class |url=http://www.mathworks.com/help/matlab/matlab_oop/implementing-operators-for-your-class.html |access-date=1 October 2013}}</ref> |
||
*[[Object Pascal]] ([[Free Pascal]],<ref>{{cite web |title=Operator Overloading |
*[[Object Pascal]] ([[Free Pascal]],<ref>{{cite web |title=Operator Overloading |website=Free Pascal Manual |url=http://www.freepascal.org/docs-html/ref/refch15.html |access-date=1 December 2014}}</ref> [[Delphi (programming language)|Delphi]] (since 2005)<ref>{{cite web |title=Operator Overloading |website=Delphi Manual |url=http://docwiki.embarcadero.com/RADStudio/XE4/en/Operator_Overloading_%28Delphi%29 |access-date=1 December 2014}}</ref>) |
||
*[[PHP]] (using magic methods,<ref>{{cite web|title=PHP magic methods overriding class properties|url=http://webwidetutor.com/php/php-oop-Magic-Methods-tutorial-?id=30| |
*[[PHP]] (using magic methods,<ref>{{cite web |title=PHP magic methods overriding class properties |url=http://webwidetutor.com/php/php-oop-Magic-Methods-tutorial-?id=30 |access-date=7 April 2015 |archive-url=https://web.archive.org/web/20160304050243/http://webwidetutor.com/php/php-oop-Magic-Methods-tutorial-?id=30 |archive-date=4 March 2016}}</ref> ArrayAccess interface, or Operator extension) |
||
*[[Perl]]<ref name="Orwant2002">{{cite book| |
*[[Perl]]<ref name="Orwant2002">{{cite book |last=Orwant |first=Jon |title=Computer Science & Perl Programming: Best of The Perl Journal |url=https://books.google.com/books?id=8TkEOyBHoOoC&q=%22operator+overloading%22&pg=PA347 |date=4 November 2002 |publisher=O'Reilly Media, Inc. |isbn=978-0-596-00310-4 |pages=347–}}</ref> |
||
*[[Python (programming language)|Python]]<ref>https://docs.python.org/3/reference/datamodel.html</ref> |
*[[Python (programming language)|Python]]<ref>{{cite web |url=https://docs.python.org/3/reference/datamodel.html |website=The Python Language Reference |title=3. Data Model}}</ref> |
||
*[[Ruby (programming language)|Ruby]]<ref>https://www.ruby-lang.org/en/documentation/faq/7/</ref> |
*[[Ruby (programming language)|Ruby]]<ref>{{cite web |url=https://www.ruby-lang.org/en/documentation/faq/7/ |website=Official Ruby FAQ |title=Methods}}</ref> |
||
*[[Rust (programming language)|Rust]]<ref>https://doc.rust-lang.org/stable/rust-by-example/trait/ops.html</ref> |
*[[Rust (programming language)|Rust]]<ref>{{cite web |url=https://doc.rust-lang.org/stable/rust-by-example/trait/ops.html |website=Rust By Example |title=Operator Overloading}}</ref> |
||
⚫ | |||
⚫ | |||
|} |
|} |
||
==Timeline of operator overloading== |
==Timeline of operator overloading== |
||
===1960s=== |
===1960s=== |
||
The [[ALGOL 68]] specification allowed operator overloading.<ref>{{cite web |title=Report on the Algorithmic Language ALGOL 68, Section 10.2.2. |url= |
The [[ALGOL 68]] specification allowed operator overloading.<ref>{{cite web |title=Report on the Algorithmic Language ALGOL 68, Section 10.2.2. |url=https://www.softwarepreservation.org/projects/ALGOL/report/Algol68_revised_report-AB-600dpi.pdf =Barry J. Mailloux |last3=Peck |first3=John E. L. |author-link3=John E. L. Peck |last4=Koster |first4= Cornelis H. A. |author-link4=Cornelis H.A. Koster |access-date=1 April 2007 |date=August 1968 |display-authors=etal}}</ref> |
||
Extract from the ALGOL 68 language specification (page 177) where the overloaded operators ¬, =, ≠, and '''abs''' are defined: |
Extract from the ALGOL 68 language specification (page 177) where the overloaded operators ¬, =, ≠, and '''abs''' are defined: |
||
10.2.2. Operations on Boolean Operands |
10.2.2. Operations on Boolean Operands |
||
a) '''op''' ∨ = ('''bool''' a, b) '''bool''':( a | '''true''' | b ); |
a) '''op''' ∨ = ('''bool''' a, b) '''bool''':( a | '''true''' | b ); |
||
Line 165: | Line 165: | ||
e) '''op''' ≠ = ('''bool''' a, b) '''bool''': ¬(a=b); |
e) '''op''' ≠ = ('''bool''' a, b) '''bool''': ¬(a=b); |
||
f) '''op''' '''abs''' = ('''bool''' a)'''int''': ( a | 1 | 0 ); |
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. |
Note that no special declaration is needed to ''overload'' an operator, and the programmer is free to create new operators. For dyadic operators their priority compared to other operators can be set: |
||
'''prio''' '''max''' = 9; |
|||
'''op''' '''max''' = ('''int''' a, b) '''int''': ( a>b | a | b ); |
|||
'''op''' '''++''' = ( '''ref''' '''int''' a ) '''int''': ( a +:= 1 ); |
|||
===1980s=== |
===1980s=== |
||
[[Ada (programming language)|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. |
[[Ada (programming language)|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. |
||
In [[C++]], operator overloading is more refined than in [[ALGOL 68]].<ref>{{cite web |title=A History of C++: 1979−1991 |
In [[C++]], operator overloading is more refined than in [[ALGOL 68]].<ref>{{cite web |title=A History of C++: 1979−1991 |url=http://www.stroustrup.com/hopl2.pdf |last=Stroustrup |first=Bjarne |author-link=Bjarne Stroustrup |page=12 |access-date=1 April 2007}}</ref> |
||
===1990s=== |
===1990s=== |
||
[[Java (programming language)|Java]] language designers at [[Sun Microsystems]] chose to omit overloading.<ref> |
[[Java (programming language)|Java]] language designers at [[Sun Microsystems]] chose to omit overloading.<ref>{{cite web |url=http://www.cafeaulait.org/javafaq.html#xtocid1902938 |website=The comp.lang.java FAQ List |title=FAQ Question 6.9: Why isn't there operator overloading?}}</ref><ref>{{cite web |url=http://java.sun.com/docs/white/langenv/Simple.doc2.html |title=java.sun.com |url-status=dead |access-date=26 March 2009 |archive-date=7 March 2009 |archive-url=https://web.archive.org/web/20090307035128/http://java.sun.com/docs/white/langenv/Simple.doc2.html }}</ref><ref>{{cite book |last=Holzner |first=Steven |title=C++: Black Book |year=2001 |publisher=Coriolis Group |location=Scottsdale, Arizona |isbn=1-57610-777-9 |page=387 |quote=One of the nicest features of C++ OOP is that you can overload operators to handle objects of your classes (you can't do this in some other OOP-centric languages, like Java).}}</ref> |
||
[[Python (programming language)|Python]] allows operator overloading through the implementation of methods with special names.<ref>{{cite web |url=https://docs.python.org/3/reference/datamodel.html#specialnames |website=The Python Language Reference |title=3. Data Model, Special method names}}</ref> For example, the addition (+) operator can be overloaded by implementing the method {{code|obj.__add__(self, other)}}. |
|||
[[Ruby (programming language)|Ruby]] allows operator overloading as syntactic sugar for simple method calls. |
[[Ruby (programming language)|Ruby]] allows operator overloading as syntactic sugar for simple method calls. |
||
Line 185: | Line 193: | ||
In [[Raku (programming language)|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: |
In [[Raku (programming language)|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: |
||
<syntaxhighlight lang="perl6"> |
<syntaxhighlight lang="perl6"> |
||
multi infix:<+>(Date:D $d, Int:D $x) { |
multi infix:<+>(Date:D $d, Int:D $x) { |
||
Line 190: | Line 199: | ||
} |
} |
||
</syntaxhighlight> |
</syntaxhighlight> |
||
Since "multi" was used, the function gets added to the list of [[multidispatch |
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 [[Imaginary unit|postfix and term '''i''']], and so on, it also allows for overloading various brace operators: "'''['''x, y''']'''", "x'''[''' |
While the capacity for overloading includes '''+''', '''*''', '''>=''', the [[Imaginary unit|postfix and term '''i''']], and so on, it also allows for overloading various brace operators: "'''['''x, y''']'''", "x'''['''y''']'''", "x'''{''y''}'''", and "x'''('''y''')'''". |
||
[[Kotlin (programming language)|Kotlin]] has supported operator overloading since its creation. |
[[Kotlin (programming language)|Kotlin]] has supported operator overloading since its creation. |
||
Line 208: | Line 218: | ||
{{Reflist|30em}} |
{{Reflist|30em}} |
||
⚫ | |||
{{Authority control}} |
{{Authority control}} |
||
Latest revision as of 05:12, 18 October 2023
Polymorphism |
---|
Ad hoc polymorphism |
Parametric polymorphism |
Subtyping |
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
[edit]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
[edit]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
[edit]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
[edit]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.
Operators | Not overloadable | Overloadable |
---|---|---|
New definable[4] | ||
Limited set |
|
Timeline of operator overloading
[edit]1960s
[edit]The ALGOL 68 specification allowed operator overloading.[44]
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. For dyadic operators their priority compared to other operators can be set:
prio max = 9; op max = (int a, b) int: ( a>b | a | b ); op ++ = ( ref int a ) int: ( a +:= 1 );
1980s
[edit]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.
In C++, operator overloading is more refined than in ALGOL 68.[45]
1990s
[edit]Java language designers at Sun Microsystems chose to omit overloading.[46][47][48]
Python allows operator overloading through the implementation of methods with special names.[49] For example, the addition (+) operator can be overloaded by implementing the method obj.__add__(self, other)
.
Ruby allows operator overloading as syntactic sugar for simple method calls.
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
[edit]Microsoft added operator overloading to C# in 2001 and to Visual Basic .NET in 2003.
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)".
Kotlin has supported operator overloading since its creation.
See also
[edit]- Function overloading
- Polymorphism (computer science)
- Subroutine
- Operator (programming)
- Operators in C and C++
- Mutator method
- Indexer (programming)
- Property (programming)
References
[edit]- ^ Stroustrup, Bjarne. "Operator Overloading". C++ FAQ. Archived from the original on 14 August 2011. Retrieved 27 August 2020.
- ^ Fisher, Charles N. (2008). "Issues in Overloading" (PDF). University of Wisconsin–Madison.
- ^ "No more operator overloading". The Java Language Environment. Oracle Corporation.
- ^ Completely new operators can be added.
- ^ Binary functions with a symbolic name can be called infix.
- ^ "Predicate op/3".
- ^ Hunt, John (6 December 2012). Smalltalk and Object Orientation: An Introduction. Springer Science & Business Media. ISBN 978-1-4471-0961-7.
- ^ "Bertrand Meyer: Basic Eiffel language mechanisms". se.ethz.ch. Retrieved 7 April 2021.
- ^ "Operator functions in F90". www.mathcs.emory.edu. Retrieved 7 April 2021.
- ^ Introduced in Fortran 90.
- ^ "3. Language Reference — Futhark 0.19.0 documentation". futhark.readthedocs.io. Retrieved 10 October 2020.
- ^ 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.
- ^ Type classes instead of overloading.
- ^ "io guide". iolanguage.org. Retrieved 7 April 2021.
- ^ "Operators".
- ^ "Operators - R in a Nutshell, 2nd Edition [Book]". www.oreilly.com. Retrieved 7 April 2021.
- ^ "Creating operators".
- ^ "Operators". Tour of Scala.
- ^ "Seed7 Manual: Structured syntax definition". seed7.sourceforge.net. Retrieved 29 September 2020.
- ^ "Swift: Advanced Operators".
- ^ "Why does Go not support overloading of methods and operators?". Retrieved 4 September 2011.
- ^ "Introduction". freepascal.org. Retrieved 30 September 2020.
- ^ "Operator Overloads". Retrieved 28 September 2018.
- ^ "6.6 Overloading of Operators". Annotated Ada Reference Manual.
- ^ Drayton, Peter; Albahari, Ben; Neward, Ted (2003). C# in a Nutshell. O'Reilly Media, Inc. ISBN 978-0-596-00526-9.
- ^ "C++ Operator Overloading".
- ^ "Eclipse Ceylon: Operator Polymorphism". ceylon-lang.org. Retrieved 7 April 2021.
- ^ "Operator Overloading - D Programming Language". dlang.org. Retrieved 10 October 2020.
- ^ "A tour of the Dart language". dart.dev. Retrieved 30 September 2020.
- ^ "Operator Overloading". bourabai.kz. Retrieved 7 April 2021.
- ^ "The Apache Groovy programming language - Operators". groovy-lang.org. Retrieved 30 September 2020.
- ^ "Operator Overloading". Manifold. Retrieved 7 June 2020.
- ^ "Operator overloading". Kotlin. Retrieved 24 June 2018.
- ^ "Metamethods Tutorial". Lua-users Wiki.
- ^ "Implementing Operators for Your Class". Retrieved 1 October 2013.
- ^ "Operator Overloading". Free Pascal Manual. Retrieved 1 December 2014.
- ^ "Operator Overloading". Delphi Manual. Retrieved 1 December 2014.
- ^ "PHP magic methods overriding class properties". Archived from the original on 4 March 2016. Retrieved 7 April 2015.
- ^ Orwant, Jon (4 November 2002). Computer Science & Perl Programming: Best of The Perl Journal. O'Reilly Media, Inc. pp. 347–. ISBN 978-0-596-00310-4.
- ^ "3. Data Model". The Python Language Reference.
- ^ "Methods". Official Ruby FAQ.
- ^ "Operator Overloading". Rust By Example.
- ^ "How to: Define an Operator (Visual Basic)".
- ^ =Barry J. Mailloux "Report on the Algorithmic Language ALGOL 68, Section 10.2.2". August 1968. Retrieved 1 April 2007.
{{cite web}}
: Check|url=
value (help) - ^ Stroustrup, Bjarne. "A History of C++: 1979−1991" (PDF). p. 12. Retrieved 1 April 2007.
- ^ "FAQ Question 6.9: Why isn't there operator overloading?". The comp.lang.java FAQ List.
- ^ "java.sun.com". Archived from the original on 7 March 2009. Retrieved 26 March 2009.
- ^ Holzner, Steven (2001). C++: Black Book. Scottsdale, Arizona: Coriolis Group. p. 387. ISBN 1-57610-777-9.
One of the nicest features of C++ OOP is that you can overload operators to handle objects of your classes (you can't do this in some other OOP-centric languages, like Java).
- ^ "3. Data Model, Special method names". The Python Language Reference.