Advanced Program Design with C++

1. Advanced Program Design with C++ Part 9: Operator overloading Joey Paquet, 2007-2019

2. Operator overloading • Sometimes using methods to implement arithmetic-style operations is not very convenient. • Let us take as an example a Rational class: classRational { public: Rational(int = 0, int = 1); // default constructor Rational(constRational & r); // copy constructor int numerator; // numerator of fraction int denominator; // denominator of fraction }; Joey Paquet, 2007-2019

3. 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: constRationalRational::add(constRational& r) const { int n = numerator * r.denominator + denominator * r.numerator; int d = denominator * r.denominator; returnRational(n, d); } Rational a(5, 6); Rational b(2, 3); Rational c(1, 2); Rational d = a.add(b.add(c)); Joey Paquet, 2007-2019

4. 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; RationalRational::operator+(constRational& a) const { Rational sum; sum.numerator = a.numerator * denominator + a.denominator * numerator; sum.denominator = a.denominator * denominator; return sum; } Joey Paquet, 2007-2019

5. 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-2019

6. Operator overloading + - * / % ^ & | ~ ! && || ++ -- << >> , < <= == != > >= = += -= *= /= %= &= |= ^= <<= >>= [ ] ( ) -> ->* new delete • Operators that can be overloaded: Joey Paquet, 2007-2019

7. 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 constRationalRational::operator-() const { Rational minus; minus.numerator = -(this->numerator); minus.denominator = this->denominator; return minus; } // unary minus free operator constRational operator-(Rational& a) { Rational minus; minus.numerator = -(a.numerator); minus.denominator = a.denominator; return minus; } Joey Paquet, 2007-2019

8. Operator overloading • Binary operators can be members with one parameter or free operators with two parameters: // binary operator+ as member operator constRationalRational::operator+(constRational& 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 constRational operator+(constRational& a, constRational& b) { Rational sum; sum.numerator = a.numerator * b.denominator + a.denominator * b.numerator; sum.denominator = a.denominator * b.denominator; return sum; } Joey Paquet, 2007-2019

9. 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 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! constRational operator+(constRational&a, constRational&b) constRationalRational::operator+(constRational&a) const Joey Paquet, 2007-2019

10. 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 RationalRational::operator++(int){ Rational temp = *this; numerator = numerator + denominator; return temp; } Joey Paquet, 2007-2019

11. 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, constRational &r) { output << r.numerator << "/" << r.denominator; returnoutput; } istream& operator>>(istream &input, Rational &r) { input >> r.numerator >> r.denominator; returninput; } cout << ++a << endl << b++ << endl << b << endl; Joey Paquet, 2007-2019

12. 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::operatordouble(){ 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-2019

13. 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. constRational& Rational::operator=(constRational& r){ numerator = r.numerator; denominator = r.denominator; return *this; } Joey Paquet, 2007-2019

14. 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: constRational& Rational::operator=(constRational& r){ numerator = newint(r.numerator); denominator = newint(r.denominator); return *this; } constRational& Rational::operator=(constRational& r){ delete numerator; delete denominator; numerator = newint(r.numerator); denominator = newint(r.denominator); return *this; } Joey Paquet, 2007-2019

15. 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; constRational& Rational::operator=(constRational& r){ if (&r != this){ delete numerator; delete denominator; numerator = newint(r.numerator); denominator = newint(r.denominator); } return *this; } Joey Paquet, 2007-2019

16. 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-2019

17. 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 constRational operator+(constRational& a, constRational& 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 constRational operator+(constRational& a, constint& 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 constRational operator+(constint& a_int, constRational& 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-2019

18. 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. classRational { public: Rational(int = 0, int = 1); // default constructor Rational(constRational & r); // copy constructor private: int numerator; // numerator of fraction int denominator; // denominator of fraction }; Joey Paquet, 2007-2019

19. 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. classRational { friendconstRational operator+(constRational&, constRational&); friendconstRational operator+(constRational&, constint&); friendconstRational operator+(constint&, constRational&); public: Rational(int = 0, int = 1); // default constructor Rational(constRational & r); // copy constructor private: int numerator; // numerator of fraction int denominator; // denominator of fraction }; Joey Paquet, 2007-2019

20. 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-2019

21. 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-2019