| Polymorphism |
|---|
| Ad hoc polymorphism |
| Parametric polymorphism |
| Subtyping |
Incomputer programming,operator overloading, sometimes termedoperatorad hoc polymorphism, is a specific case ofpolymorphism, where differentoperators have different implementations depending on their arguments. Operator overloading is generally defined by aprogramming language, aprogrammer, or both.
Operator overloading issyntactic 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 theexpressive power of a language (with functions), as it can be emulated using function calls. For example, consider variablesa,b andc of some user-defined type, such asmatrices:
a + b * c
In a language that supports operator overloading, and with the usual assumption that the* operator has higherprecedence than the+ operator, this is a concise way of writing:
Add(a, Multiply(b, c))
However, the former syntax reflects common mathematical usage.
In this case, the addition operator is overloaded to allow addition on a user-defined typeTime inC++:
Timeoperator+(constTime&lhs,constTime&rhs){Timetemp=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;returntemp;}
Addition is abinary operation, which means it has twooperands. In C++, the arguments being passed are the operands, and thetemp object is the returned value.
The operation could also be defined as a class method, replacinglhs by the hiddenthis argument; However, this forces the left operand to be of typeTime:
// The "const" right before the opening curly brace means that `this` is not modified.TimeTime::operator+(constTime&rhs)const{Timetemp=*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;returntemp;}
Note that aunary operator defined as a class method would receive no apparent argument (it only works fromthis):
boolTime::operator!()const{returnhours==0&&minutes==0&&seconds==0;}
The less-than (<) operator is often overloaded to sort a structure or class:
classIntegerPair{private:intx;inty;public:explicitIntegerPair(intx=0,inty=0):x{x},y{y}{}booloperator<(constIntegerPair&p)const{if(x==p.x){returny<p.y;}returnx<p.x;}};
Like with the previous examples, in the last example operator overloading is done within the class. In C++, after overloading the less-than operator (operator<),standard sorting functions can be used to sort some classes.
Starting inC++20 with the introduction of thethree-way comparison operator (operator<=>), all the order operators can be defined by just defining that operator. The three-way comparison operator exists in many languages, includingC++,Python,Rust,Swift, andPHP. Other languages, such asJava andC# instead use a methodComparable.compareTo().
importstd;usingstd::strong_ordering;classIntegerPair{private:intx;inty;public:explicitIntegerPair(intx=0,inty=0):x{x},y{y}{}// can be auto-generated with = default;strong_orderingoperator<(constIntegerPair&p)const{if(strong_orderingcmp=x<=>p.x;cmp!=strong_ordering::equal){returncmp;}returny<=>p.y;}};
Operator overloading has often been criticized[weasel words][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 inC++a<<b shifts the bits in the variablea left byb bits ifa andb are of an integer type, but ifa is an output stream then the above code will attempt to write ab 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 ofJava decided not to use this feature,[3] although not necessarily for this reason[original research?]).
Another, more subtle, issue with operators is that certain rules from mathematics can be wrongly expected or unintentionally assumed. For example, thecommutativity of + (i.e. thata + 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 alwaysassociative, 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 inmatrix multiplication.
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 |
TheALGOL 68 specification allowed operator overloading.[36]
Extract from the ALGOL 68 language specification (page 177) where the overloaded operators ¬, =, ≠, andabs are defined:
10.2.2. Operations on Boolean Operandsa)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)opabs = (bool a)int: ( a | 1 | 0 );
Note that no special declaration is needed tooverload an operator, and the programmer is free to create new operators. For dyadic operators their priority compared to other operators can be set:
priomax = 9;opmax = (int a, b)int: ( a>b | a | b );op++ = (refint a )int: ( a +:= 1 );
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.
InC++, operator overloading is more refined than inALGOL 68.[37]
Java language designers atSun Microsystems chose to omit overloading.[38][39][40] When asked about operator overloading, Brian Goetz ofOracle responded "Value types first, then we can talk about it.", suggesting that it could potentially be added afterProject Valhalla.[41]
Python allows operator overloading through the implementation of methods with special names.[42] For example, the addition (+) operator can be overloaded by implementing the methodobj.__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.
Microsoft added operator overloading toC# in 2001 and toVisual Basic .NET in 2003. C# operator overloading is very similar in syntax to C++ operator overloading:[43]
publicclassFraction{privateintnumerator;privateintdenominator;// ...publicstaticFractionoperator+(Fractionlhs,Fractionrhs)=>newFraction(lhs.numerator*rhs.denominator+rhs.numerator*lhs.denominator,lhs.denominator*rhs.denominator);}
Scala treats all operators as methods and thus allows operator overloading by proxy.
InRaku, 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 theRakudo source for incrementing a Date object with "+" is:
multiinfix:<+>(Date:D$d,Int:D$x) {Date.new-from-daycount($d.daycount +$x)}
Since "multi" was used, the function gets added to the list ofmultidispatch candidates, and "+" is only overloaded for the case where the type constraints in the function signature are met.While the capacity for overloading includes+,*,>=, thepostfix and termi, and so on, it also allows for overloading various brace operators:[x, y],x[y],x{y}, andx(y).
Kotlin has supported operator overloading since its creation by overwriting specially named functions (likeplus(),inc(),rangeTo(), etc.)[44]
dataclassPoint(valx:Int,valy:Int){operatorfunplus(other:Point):Point{returnPoint(this.x+other.x,this.y+other.y)}}
Because both Kotlin and Java compile to.class, when converted back toJava this will just be represented as:
publicclassPoint{// fields and constructor...publicPointplus(Pointother){returnnewPoint(this.x+other.x,this.y+other.y);}}
Operator overloading inRust is accomplished by implementing thetraits instd::ops.[45]
usestd::ops::Add;#[derive(Debug)]structPoint{x:i32,y:i32}implPoint{pubfnnew(x:i32,y:i32)->Self{Point{x,y}}}implAddforPoint{typeOutput=Point;fnadd(self,other:Point)->Point{Point{x:self.x+other.y,y:self.y+other.y}}}fnmain(){letp1:Point=Point::new(1,2);letp2:Point=Point::new(3,4);letsum:Point=p1+p2;println!("Sum of p1 and p2: {:?}",sum);}
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).
