Advanced Program Design with C++ COMP 345 - Advanced Program Design with C++ Advanced Program Design with C++ Part 9: Operator overloading Joey Paquet, 2007-2018

Let us take as an example a Rational class: COMP 345 - Advanced Program Design with C++ Operator overloading Sometimes using methods to implement arithmetic-style operations is not very convenient. Let us take as an example a Rational class: class Rational { public: Rational(int = 0, int = 1); // default constructor Rational(const Rational & r); // copy constructor int numerator; // numerator of fraction int denominator; // denominator of fraction }; Joey Paquet, 2007-2018

COMP 345 - Advanced Program Design with C++ Operator overloading To implement the addition of two Rational objects, the following method could be added: Such a method would require that we add three Rational numbers in the following awkward manner: const Rational Rational::add(const Rational& r) const { int n = numerator * r.denominator + denominator * r.numerator; int d = denominator * r.denominator; return Rational(n, d); } Rational a(5, 6); Rational b(2, 3); Rational c(1, 2); Rational d = a.add(b.add(c)); Joey Paquet, 2007-2018

COMP 345 - Advanced Program Design with C++ Operator overloading Since the addition operation has an arithmetic flavor to it, it would make much more sense if we could write: C++ provides a very convenient way to implement arithmetic-style operators: operator overloading. Rational d = a + b + c; Rational Rational::operator+(const Rational& a) const { Rational sum; sum.numerator = a.numerator * denominator + a.denominator * numerator; sum.denominator = a.denominator * denominator; return sum; } Joey Paquet, 2007-2018

Otherwise it would be confusing. COMP 345 - Advanced Program Design with C++ Operator overloading Operator overloading allows existing C++ operators to work with user-defined data types. Limitations: At least one operand must be a user-defined type, i.e. it is impossible to change the meaning of an operator applied to a basic type such as int. Restricted to a fixed set of operators. Cannot change precedence and associativity of operators. Should not change the meaning of an operator, e.g. operator+ should always do something similar to addition. Otherwise it would be confusing. Joey Paquet, 2007-2018

COMP 345 - Advanced Program Design with C++ Operator overloading Operators that can be overloaded: + - * / % ^ & | ~ ! && || ++ -- << >> , < <= == != > >= = += -= *= /= %= &= |= ^= <<= >>= [ ] ( ) -> ->* new delete Joey Paquet, 2007-2018

COMP 345 - Advanced Program Design with C++ Operator overloading Operators can be overloaded either as member functions or as free operators. Unary operators can be members with no parameter or free operators with one parameter: // unary minus member operator const Rational Rational::operator-() const { Rational minus; minus.numerator = -(this->numerator); minus.denominator = this->denominator; return minus; } // unary minus free operator const Rational operator-(Rational& a) { Rational minus; minus.numerator = -(a.numerator); minus.denominator = a.denominator; return minus; } Joey Paquet, 2007-2018

COMP 345 - Advanced Program Design with C++ Operator overloading Binary operators can be members with one parameter or free operators with two parameters: // binary operator+ as member operator const Rational Rational::operator+(const Rational& a) const { Rational sum; sum.numerator = a.numerator * this->denominator + a.denominator * this->numerator; sum.denominator = a.denominator * this->denominator; return sum; } // binary operator+ as free operator const Rational operator+(Rational& a, Rational& b) { Rational sum; sum.numerator = a.numerator * b.denominator + a.denominator * b.numerator; sum.denominator = a.denominator * b.denominator; return sum; } Joey Paquet, 2007-2018

COMP 345 - Advanced Program Design with C++ Operator overloading The result of operators should be a new value returned by the operator, which should be constant, so that the result cannot be the target of an assignment: Parameters should be passed by value or preferably by constant reference, as the operands should not be modified by the operations. Member operators should be declared as constant to signify that the operation does not alter the calling object. Rational r1(1,2), r2(2,3), r3(0,1); (r1 + r2) = r3; //should not be allowed! const Rational Rational::operator+(const Rational& a) const Joey Paquet, 2007-2018

Increment/decrement operators overloading COMP 345 - Advanced Program Design with C++ Operator overloading Increment/decrement operators overloading Prefix: increments and then returns value Postfix: increments but returns original value. Note: postfix operator uses a dummy int parameter // prefix increment operator Rational& Rational::operator++(){ numerator = numerator + denominator; return *this; } // postfix increment operator Rational Rational::operator++(int){ Rational temp = *this; numerator = numerator + denominator; return temp; } Joey Paquet, 2007-2018

Stream input/output operators overloading. COMP 345 - Advanced Program Design with C++ Operator overloading Stream input/output operators overloading. Must be overloaded as free operators. Uses the stream input/output operators to input/output individual values of the data members. Returns the stream as a reference so that it can then be used sequentially, e.g. : ostream& operator<<(ostream &output, const Rational &r) { output << r.numerator << "/" << r.denominator; return output; } istream& operator>>(istream &input, Rational &r) { input >> r.numerator >> r.denominator; return input; } cout << ++a << endl << b++ << endl << b << endl; Joey Paquet, 2007-2018

Can implement casting operators: COMP 345 - Advanced Program Design with C++ Operator overloading Can implement casting operators: Will be called implicitly by the compiler when necessary, e.g. : Or when an explicit cast is made, e.g. : Note that the casting operator has very high precedence: Rational::operator double(){ return numerator / (double)denominator; } Rational b(2, 3); float f = b; //casting operator implicitly called cout << b++ << endl << b << endl << (float)b << endl; Joey Paquet, 2007-2018

Overloading the assignment operator: COMP 345 - Advanced Program Design with C++ Operator overloading Overloading the assignment operator: The assignment operator returns a reference to its result, so that a cascade of assignments is possible. If an assignment operator is not provided, the compiler will generate one automatically, which will do a member-wise shallow copy. If no data members are pointers, an assignment operator does not need to be explicitly overloaded. If the class contains pointer members, the assignment operator must be explicitly overloaded, or else it will be only copying the pointer values. const Rational& Rational::operator=(const Rational& r){ numerator = r.numerator; denominator = r.denominator; return *this; } Joey Paquet, 2007-2018

COMP 345 - Advanced Program Design with C++ Operator overloading Let us imagine that numerator and denominator are int*, then we may have the following assignment operator: This would in fact create a memory leak, as the memory previously reserved to numerator and denominator has not been deleted. So what we need seems to be the following: const Rational& Rational::operator=(const Rational& r){ numerator = new int (r.numerator); denominator = new int (r.denominator); return *this; } const Rational& Rational::operator=(const Rational& r){ delete numerator; delete denominator; numerator = new int (r.numerator); denominator = new int (r.denominator); return *this; } Joey Paquet, 2007-2018

But then let us imagine that we do a self-assignment, e.g. : COMP 345 - Advanced Program Design with C++ Operator overloading But then let us imagine that we do a self-assignment, e.g. : This would in fact lead us to delete the memory allocated to the pointers first, and then try to copy their value, which would fail. So we also need to do a self-assignment check: Rational a(5, 6); a = a; const Rational& Rational::operator=(const Rational& r){ if (&r != this){ delete numerator; delete denominator; numerator = new int (r.numerator); denominator = new int (r.denominator); } return *this; Joey Paquet, 2007-2018

There are some problems with the use of member operators. COMP 345 - Advanced Program Design with C++ Operator overloading There are some problems with the use of member operators. For example, what if we want to do the following (legitimate) operation: This requires the operator+ to be overloaded in the Rational class again, but this time taking a parameter of type int. However, this does not entirely solve the problem, as we might want to do: In this case, what would be needed is to overload the operator+ for int that would take a parameter of type Rational. Unfortunately, we cannot do that. Rational a(5, 6); Rational c = a + 25; Rational a(5, 6); Rational c = 25 + a; Joey Paquet, 2007-2018

So the best solution is to define our operators as free operators. COMP 345 - Advanced Program Design with C++ Operator overloading So the best solution is to define our operators as free operators. This way, we can overload them with any operand type we need, as both of the operands are explicitly mentioned. // operator+ as free operator const Rational operator+(const Rational& a, const Rational& b) { Rational sum; sum.numerator = a.numerator * b.denominator + a.denominator * b.numerator; sum.denominator = a.denominator * b.denominator; return sum; } // operator+ as free operator const Rational operator+(const Rational& a, const int& b_int) { Rational sum, b(b_int,1); sum.numerator = a.numerator * b.denominator + a.denominator * b.numerator; sum.denominator = a.denominator * b.denominator; return sum; } // operator+ as free operator const Rational operator+(const int& a_int, const Rational& b) { Rational sum, a(a_int,1); sum.numerator = a.numerator * b.denominator + a.denominator * b.numerator; sum.denominator = a.denominator * b.denominator; return sum; } Joey Paquet, 2007-2018

COMP 345 - Advanced Program Design with C++ Operator overloading Let us redefine our class so that the data members are now private, which is better practice: Then our three overloaded free operator+ don’t work anymore, as they cannot access the private members of the class Rational. class Rational { public: Rational(int = 0, int = 1); // default constructor Rational(const Rational & r); // copy constructor private: int numerator; // numerator of fraction int denominator; // denominator of fraction }; Joey Paquet, 2007-2018

COMP 345 - Advanced Program Design with C++ Operator overloading A solution would be to provide accessors for numerator and denominator, which is something that we may not want to do, as it would expose the data to the exterior. A better solution is to declare the free operators as friends to the Rational class. In fact, this is one of the most common use of friends. class Rational { friend const Rational operator+(const Rational&, const Rational&); friend const Rational operator+(const Rational&, const int&); friend const Rational operator+(const int&, const Rational&); public: Rational(int = 0, int = 1); // default constructor Rational(const Rational & r); // copy constructor private: int numerator; // numerator of fraction int denominator; // denominator of fraction }; Joey Paquet, 2007-2018

As non-member non-friend COMP 345 - Advanced Program Design with C++ Operator overloading As member Defined as a member of the class. May use data members, as the operator is a member of the class. Operator belongs to the class (as opposed to non-member). Best from the point of view of OO principles, but… The calling object is the left operand of the operator, so thus this suffers from lack of type conversion of the left operand if it is a basic type. As non-member non-friend Defined as external to the class. Not related nor mentioned in the class, except by its operands type. Implementation code cannot refer to private members of its operands, thus necessitating accessors, which might not be desirable. Declares all operands and no calling object. May accommodate different types for all its operands. As friend Defined as external to the class, but introduced inside the class as a friend At least, it is mentioned in the class declaration, though it is not a member. As a friend, it may use private data members, thus does not necessitate accessors. Has two declared operands and no calling object. May have type conversion for both of its operands. Joey Paquet, 2007-2018

References Michigan Technical University. Operator overloading. COMP 345 - Advanced Program Design with C++ References Michigan Technical University. Operator overloading. Paul Deitel, Harvey Deitel. C++ How To Program. Prentice Hall, 2011. ISBN-13: 978-0132662369 Y. Daniel Liang. Introduction to Programming with C++. Chapter 14. Prentice Hall, 2014. ISBN-13: 978-0133252811 Joey Paquet, 2007-2018