Tuesday, April 23, 2013

Operator Overloading in C++ & Scala

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
Contrary to Java,  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.

Note: 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

C++
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
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).



Reference
Scala for the Impatient - C. Horstman - Addison-Wesley 2012
The Annotated C++ Reference Manual - M. Ellis,  B. Stroustrup - Addison-Wesley 1991

No comments:

Post a Comment