Concordia University Department of Computer Science and Software Engineering Click to edit Master title style ADVANCED PROGRAM DESIGN WITH C++ Part 9: Operator overloading Joey Paquet, COMP Advanced Program Design with C++

Concordia University Department of Computer Science and Software Engineering Sometimes using methods to implement arithmetic-style operations is not very convenient. Let us take as an example a Rational class: Operator overloading Joey Paquet, COMP Advanced Program Design with C++ 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 };

Concordia University Department of Computer Science and Software Engineering 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: Operator overloading Joey Paquet, COMP Advanced Program Design with C++ 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));

Concordia University Department of Computer Science and Software Engineering 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. Operator overloading Joey Paquet, COMP Advanced Program Design with C++ 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; }

Concordia University Department of Computer Science and Software Engineering 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. Operator overloading Joey Paquet, COMP Advanced Program Design with C++

Concordia University Department of Computer Science and Software Engineering + - * / % ^ & | ~ ! && || >, < >= = += -= *= /= %= &= |= ^= >= [ ]( ) -> ->* new delete Operator overloading Joey Paquet, COMP Advanced Program Design with C++ Operators that can be overloaded:

Concordia University Department of Computer Science and Software Engineering 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: Operator overloading Joey Paquet, COMP Advanced Program Design with C++ // 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; }

Concordia University Department of Computer Science and Software Engineering Binary operators can be members with one parameter or free operators with two parameters: Operator overloading Joey Paquet, COMP Advanced Program Design with C++ // 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; } // 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; }

Concordia University Department of Computer Science and Software Engineering 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. Operator overloading Joey Paquet, COMP Advanced Program Design with C++ 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

Concordia University Department of Computer Science and Software Engineering Increment/decrement operators overloading Prefix: increments and then returns value Postfix: increments but returns original value. Note: postfix operator uses a dummy int parameter Operator overloading Joey Paquet, COMP Advanced Program Design with C++ // 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; }

Concordia University Department of Computer Science and Software Engineering 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. : Operator overloading Joey Paquet, COMP Advanced Program Design with C++ 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;

Concordia University Department of Computer Science and Software Engineering 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: Operator overloading Joey Paquet, COMP Advanced Program Design with C++ 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;

Concordia University Department of Computer Science and Software Engineering 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. Operator overloading Joey Paquet, COMP Advanced Program Design with C++ const Rational& Rational::operator=(const Rational& r){ numerator = r.numerator; denominator = r.denominator; return *this; }

Concordia University Department of Computer Science and Software Engineering 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: Operator overloading Joey Paquet, COMP Advanced Program Design with C++ 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; }

Concordia University Department of Computer Science and Software Engineering 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: Operator overloading Joey Paquet, COMP Advanced Program Design with C++ 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; } Rational a(5, 6); a = a;

Concordia University Department of Computer Science and Software Engineering 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. Operator overloading Joey Paquet, COMP Advanced Program Design with C++ Rational a(5, 6); Rational c = a + 25; Rational a(5, 6); Rational c = 25 + a;

Concordia University Department of Computer Science and Software Engineering 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 overloading Joey Paquet, COMP Advanced Program Design with C++ // 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; }

Concordia University Department of Computer Science and Software Engineering 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. Operator overloading Joey Paquet, COMP Advanced Program Design with C++ 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 };

Concordia University Department of Computer Science and Software Engineering 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. Operator overloading Joey Paquet, COMP Advanced Program Design with C++ 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 };

Concordia University Department of Computer Science and Software Engineering 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. Operator overloading Joey Paquet, COMP Advanced Program Design with C++

Concordia University Department of Computer Science and Software Engineering Michigan Technical University. Operator overloading.Operator overloading Paul Deitel, Harvey Deitel. C++ How To Program. Prentice Hall, ISBN-13: Y. Daniel Liang. Introduction to Programming with C++. Chapter 14. Prentice Hall, ISBN-13: References Joey Paquet, COMP Advanced Program Design with C++