159.234 LECTURE 13

1. 159.234LECTURE 13 Operator Overloading • Today: • const member functions • Overloading Operators • Postfix/infix increment operator • Binary operators overloading • Overloading I/O operators Textbook p.203—216

2. const Member Functions A member function that is notallowed to modify data members of its class is declared as a constmember function. class Point { public: Point(): x(0),y(0){}; Point(inta,int b){x = a;y = b;} void print() const; private: intx, y; }; void Point::print() const{ cout <<" x = " << x <<", y = " << y; }

3. const Member Functions CORRECT: void Point::print() const { cout <<" x = " << x <<", y = " << y;} WRONG: void Point::print() const { x=4;cout <<" x = " << x <<", y = " << y;} Error message: Cannot modify a const object.

4. Operator Overloading We have already seen Function overloading. Operators + - etc, can also be re-defined! User-defined types can be treated in exactly the same way as simple types. e.g. for a 'complex' type we can allow the addition of two variables. Operators can be thought of as functions: -x -> negate(x) x+y -> add(x,y) with operator overloading, we use 'natural operators’ rather than having to use functions.

5. Operator Overloading We can overload: arithmetic + - etc logical && || comparison > == etc assignment = index [] function () structure pointer -> new, delete Only 4 operators cannot be overloaded: dot . conditional ?: scope :: sizeof

6. Operator Overloading Although the semantics of an operator can be extended, we cannot change its syntax, the grammatical rules that govern its use, such as the number of operands, precedence and associativity remains the same. e.g. the multiplication operator will enjoy higher precedence than the addition operator. When an operator is overloaded, its original meaning is not lost. e.g. An operator+ that is overloaded to add two vectors, can still be used to add two integers.

7. Defining Operator Overloading To define an additional task to an operator, we must specify what it means in relation to the class to which the operator will be applied. This is done with the help of a special function called operatorfunction which describes the task. General form of an operator function: return typeclassname :: operator (op-arglist) { function body //task defined } Operator being overloaded operator is the function name

8. Binary Operator Overloading Using a member function e.g. overloading the + operator: class clock { public: clock(int seconds=0) : total(seconds) {} clock operator+(int seconds) { clock temp; temp.total= total + seconds; return temp; } void print(void) {cout << total << endl;} private: inttotal; }; ... clock a(50), b; b = a + 10; b.print(); There is an implicit first argument (the this pointer). It takes some time to get used to it. Allows only expressions with an object on the left-hand side of the operator

9. Binary Operator Overloading Using a friend function e.g. overloading the + operator: class clock { public: clock(int seconds=0) : total(seconds) {} //for construction and conversion friend clock operator+(clock c1, clock c2); void print(void) {cout << total << endl;} private: int total; }; clock operator+(clock c1, clock c2) { return (c1.total + c2.total); } It is normal for symmetric Binary operators to be overloaded by friend functions.

10. Unary Operator Overloading e.g. overloading the prefix ++ operator: class clock { public: clock(int seconds=0) : total(seconds) {} clock operator++() { total++; return *this; } void print(void) {cout << total << endl;} private: inttotal; }; ... a = ++b; b.print();

11. Overloading the postfix ++ Operator Can we differentiate between prefix and postfix? In the code previously shown - the compiler uses the overloaded ++ for both postfix and prefix. To create different prefix and postfix versions we need some help from the compiler. The compiler knows whether the code is prefix or postfix. If it is postfix the compiler uses an 'ad hoc' convention, it tries to find a version of operator++ with an integer argument: The value of the integer is irrelevant, but it gives us the chance to write two different functions. clock operator++(int) { clock temp = *this; total++; return temp; }

12. Overloading the [ ] Operator class vect { public: vect(int n) : size(n) { p = new int[size]; assert(p!=NULL); for (inti=0;i<size;i++) { p[i] = 0; } } ~vect() {delete [] p;} int& operator[](inti) { assert((i>=0) && (i<size)); return p[i]; } private: int *p; int size; }; Arrays are often abused. Range violations are common. Negative indices or indices greater than the maximum cause programs to access wrong data. We can create an array class that overloads [ ], and checks array bounds: Returning a reference to p[i] does not return a copy of p[i], but returns p[i] itself!

13. Operator Overloading Why does operator[] return an int & rather than an int? vect v(10); inti; i = v[0];// read the value at v[0]; v[0] = 3;// write to v[0]! // we return a reference // so we can alter the value Functions that return references can appear on the left hand side of an assignment statement!

14. Operator Overloading We have seen several examples of how operators can be overloaded – but this is not the whole story. a  b //where  is an operator +, - , etc is replaced by the compiler with: a.operator(b) and it then looks to see whether you have written this particular member function. 'this' becomes the lhs and b the rhs.

15. Operator Overloading 1 a.operator(b) It also checks the 'type' of b - so operator can be overloaded. If it cannot find any member function that matches, it replaces the text with: operator(a,b) A non-member function, with two arguments, and tries again to find a match in the functions you have defined. You may choose to use either way. 2

16. Operator Overloading We are not allowed to overload operators for the standard types operator+(inti, int j)will not work. This leads to some difficulties. Suppose we have a clock class, and want to be able to say: clock a,b,c; c = a + b; This works if we have either a member function of clock clock clock::operator+(clock y); or a non-member function: clock operator+(clock x, clock y);

17. Operator Overloading Suppose we also want to say: c = a + 10; This is ok if we have either clock clock::operator+(inti); or clock operator+(clock x, inti); What if we want to say: c = 10 + a; Now we run in to difficulties. The compiler cannot convert this into a member function because we are not allowed to treat 'int' as a class and overload its operators. int::operator(clock x); is wrong!

18. Operator Overloading The compiler can only try to match: clock operator+(inti, clock x); We have lost symmetry. If we want to allow 10 + a as well as a + 10 then it is neater to make them both non-member functions. Non-member functions cannot access private data! We must either make them friends, (frowned on, perhaps) or provide functions to access the data – get() and set() routines, or whatever we want to call them (better but more work)

19. Operator Overloading Remember that some operators change the value of one of their arguments, and others do not. c++; the increment operator adds one to the value of c a + b operator+ does notchange the value of either a or b, it returnstheir sum

20. Overloading I/O Operators cout << a; Can we overload the output operator? Yes – but remember that the compiler first tries to find a member function of the ostream class (cout is an object of ostream), that accepts a clock object as a parameter cout.operator<<(a); The writer of the ostream class will not have included this function! And you cannot add it. Our only option is to supply the compiler with a non-member function to match operator<<(cout, a);

21. Operator Overloading class clock { clock(int seconds=0); friend ostream & operator<<(ostream &out, const clock &x); friend istream & operator>>(istream &in, clock &x); ... unsigned long total; }; ostream&operator<<(ostream &out, const clock &x) { int h, m, s; h = x.total / 3600; m = (x.total / 60) % 60; s = x.total % 60; out << h << “:” << m << “:” << s; return out; } Stream extraction (output) operator Note: operator precedence: left to right operator<< (also known as stream deletion operator)is usually called several times in a single statement. Consequently, the output of each call to operator<< cascades into the next call as input. That’s why it needs to return a reference to the output stream (cout).

22. Operator Overloading Stream insertion (input) operator istream & operator>>(istream &in, clock &x) { int h, m, s; in >> h >> m >> s; //input retrieved as hms x.total = h*3600 + m*60 + s; return in; }

23. Operator Overloading • Overloading the assignment operator. • The copy constructor is called whenever we • pass an object as an argument, • return an object, or • intialise an object with one of the same type • There is a need for a copy constructor because the default system copy constructor performs only shallow copy, and is not normally adequate when pointers are involved. • Therefore, we need to perform a deep copy to copy what the pointers are pointing to.

24. Operator Overloading When we assign an object to another: str a, b; a = b; NO copy constructor is involved. It is an assignment. If we want assignment to behave like a deep copy constructor, we need to overload the assignment operator. str&str::operator=(const str&x){ delete[] s; s = new char[128]; strcpy(s, x.s); return *this; } Rule of thumb: Any time a class needs an explicit copy constructor defined, it also needs an assignment operator defined.

25. Argument Types Argument types. You may always pass objects as arguments – sometimes we really want to – but most times, if we do, they lead to very inefficient code. If you pass across an object a copy constructor will be called. Instead of passing an object – most of the time we pass a reference to an object instead. Only a pointer is copied! However, passing a reference is not normally acceptable. If the actual argument to a function is a constant, then the compiler will not let you pass it to a reference parameter – the function may try to change the value of a constant!

26. Argument Types The answer is to pass a 'const' referenceparameter. Now the compiler can check that the function does not change its value (it will complain if it does try to) and constant can safely be passed in the knowledge that they can't be changed. Passing a const reference is more efficient than passing an object.

27. Return Types These are again quite complicated. It is tempting to think that the assignment operator does not 'return' anything and so it should be void void str::operator=(str x) However this is NOTcorrect. It is perfectly correct to write a = b = c; which is the same as: a = (b = c); (b = c) has the 'value' of a. operator=must return an str object. Or to make it more efficient a reference to an str object. Associativity of assignment operator: Right

28. Return Types Should it return a const reference? Well surprisingly no! We may want to stop anyone from writing: (a = b) = c; but strangely enough this is legal for integers! (i = 3) = 2; first it assigns 3 to i and then assigns 2 to i And if we can do it with integers we should be allowed to do it with strings.

29. Return Types There was one final blunder when we overloaded the assignment operator for strings! a = a; Isn't very sensible, but it is legal. A program that uses our str class will fail if this statement occurs. We must modify our function as follows: str & str::operator=(const str &x){ if (&x == this) { return *this; } delete[] s; s = new char[128]; strcpy(s,x.s); return *this; } Allows multiple assignment with right-to-left associativity to be defined

30. Overloading Assignment and Subscripting Operators Common Characteristics • Must be done as non-static member functions • Usually involve a reference return type

31. Return Types Be careful when returning reference types. Consider the case of the prefix ++ operator: clock&operator++(){ total++; return *this; } This is ok, and more efficient than returning a clock object (a constructor would be called!)

32. Return Types But in the case of the postfix ++ operator: clock& operator++(int) { clock temp = *this; total++; return temp; } This is wrong!We are returning a reference to temp, and temp no longer exists! For certain functions we must return an object, not a reference. const clock operator++(int) { clock temp = *this; total++; return temp; }

35. Return Types Postfix ++ is nearly always less efficient than prefix ++ for user defined classes. view Clock3.cpp To see demo: