Target audience: Beginner
Estimated reading time: 4'
Operator overloading allows for a reinterpretation of existing operators by imparting a distinct significance to them, all while preserving their original function. This is an example of compile-time polymorphism.
While C++ offers the capability to assign unique meanings to operators for specific data types, how does its approach align with that of Scala's operator overloading?
Table of contents
Overview
In object-oriented programming, operator overloading is a specific case of polymorphism, where different operators may have different implementations depending on their arguments. The main benefit of operator overloading is to allow the developer to program using notation relevant to the domain (i.e. summation of vectors) and allows user-defined types a similar level.
C++ and Scala supports overloaded or redefinition of operators.
There is however a distinction between C++ and Scala in terms of operator overloading: In Scala the operators are over-loadable by the programmer who create methods with operator name while in C++ the operators are over-loadable by the language as a predefined set.
Notes:
- For the sake of readability of the implementation of algorithms, all non-essential code such as error checking, comments, exception, validation of class and method arguments, scoping qualifiers or import is omitted.
- Scala version used in 2.11.8
C++ operator overloading
In C++, operator overloading instructs the compiler to perform a certain operation when its corresponding operator is used on one or more variables. However, the && , || and comma operators cannot be overloaded.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 | class Point {
private:
int x;
int y;
public:
// Constructor
Point(int x = 0, int y = 0) : x(x), y(y) { }
// overloading += operator
Point& operator+=(const Point& p) {
this.x += x;
this.y += y;
return (*this);
}
Point operator+(const Point& p) {
Point result;
result.x = x + p.getX();
result.y = y + p.getY();
return result,
}
friend std::ostream& operator<<(std::ostream& out, Point p) {
out << "(" << p.getX() << "," << p.getY() << ")";
return out;
}
};
int main() {
Point p1(4, 5), p2(5, 11)
cout << "p1=" << p1 << "p1 + p2=" << p1+p2;
return 0;
}
|
Scala overloading by proxy
Scala does not technically have operator overloading because it does not have operators in the common sense. The operators are indeed function name defined by the programmer. Scala treats all operators as methods and thus allows operator overloading by proxy. 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 | final class Point(val x: Int, val y: Int) {
// Binary operator
def +(p : Point) : Point = {
require(p != null, "cannot add a null point")
new Point(x + p.x, y + p.y)
}
override def toString : String = s"(${x.toString},${y.toString)"
}
object Overload extends App {
val p1 = new Point(2, 0)
val p2 = new Point(4, -2)
Console.println(s"p1=$p1 and p1+p2=${(p1 + p2)}")
}
|
The class Point is immutable as the coordinate, x and y are declared private value. It is highly recommended to create immutable objects and containers because it reduced the object state lifecycle. Immutability avoids the need of complex and error-prone concurrent update of the state of an object (race condition).
Thank you for reading this article. For more information ...
References
- Scala for the Impatient - C. Horstman - Addison-Wesley 2012
- The Annotated C++ Reference Manual - M. Ellis, B. Stroustrup - Addison-Wesley 1991
- github.com/patnicolas
---------------------------
Patrick Nicolas has over 25 years of experience in software and data engineering, architecture design and end-to-end deployment and support with extensive knowledge in machine learning.
He has been director of data engineering at Aideo Technologies since 2017 and he is the author of "Scala for Machine Learning" Packt Publishing ISBN 978-1-78712-238-3
He has been director of data engineering at Aideo Technologies since 2017 and he is the author of "Scala for Machine Learning" Packt Publishing ISBN 978-1-78712-238-3
