CS240 C Operator Overloading Dick Steflik Operator Overloading

CS-240 C++ Operator Overloading Dick Steflik

Operator Overloading • What is it? – assigning a new meaning to a specific operator when used in the context of a specific class • ex. << is normally the shift left operator; but when used in conjunction with the class iostream it becomes the operator insertion; this is because the writers of the iostream class overloaded << to be insertion – cout << “some string” << endl; • remember cout is a predefined object of class iostream – in another class, << could be overloaded to mean something else

Operator Overloading • Why do we do it? – the c++ developers felt that it made more sense to overload an operator than to come up with some name for a function than meant the same thing as the operator. – using an overloaded operator takes fewer keystrokes – many people feel that an overloaded operator is more self documenting

Operator Overloading • Three basic ways: – as a free function (not part of a class) – as a member function – as a friend function

Operator Overloading class Rational { Rational (int , int); const Rational & operator = (const Rational & rhs); const Rational & operator + (const Rational & rhs); bool operator == (const Rational & rhs); int get. Numer() const { return numer; } int get. Denom() const { return denom; } private: int numer; int denom; }

Overloading = as a member const Rational & Rational : : operator = (const Rational & rhs) { if (this != &rhs) { numer = rhs. numer; denom = rhs. denom; } return *this } Rational r 1 , r 2; r 1 = r 2; -note: the if statement catches the special case where someone is trying r 1=r 1, the if statement makes the code faster

Overloading + as a member const Rational: : operator + (const Rational & rhs) { } Rational answer ( *this); // initialize the answer with the current object answer += rhs; // add the second operand (assumes += has been overloaded) return answer; // return the answer via the copy constructor

Overloading == as a free function // not defined in the Rational class bool operator == (const & Rational lhs , const & Rational rhs) { return (lhs. get. Denom() * rhs. get. Numer() == lhs. get. Numer() * rhs. get. Denom()); } Rational r 1 , r 2; if ( r 1 == r 2 ) cout……… else cout

Overloading == as a member const bool Rational: : operator == (const Rational & rhs ) { return ( numer * rhs. denom == denom * rhs. numer); } Rational r 1 , r 2 ; if (r 1 == r 2 ) cout ……. else cout ……

Friend Functions • not a member function • has access to private data • member functions work with the current (named object) friend functions work with multiple objects of the same class • tag as a friend of the class – as part of class definition identify, by prototype, each friend of the class

Friend Functions (cont. ) • Friend functions are needed in C++ due to C++’s flawed object model, Java has a better model (all objects are derived from a single object). • define the prototype in the public section of the class definition • precede the prototype with the keyword “friend”

Friend Functions (more) • define the friend implementation in the. cpp file with the member functions • do not precede the function name with the class name and the scoping operator (ex. classname: : )

Overloading == as a friend class Rational { Rational (int , int); const Rational & operator = (const Rational & rhs); const Rational & operator + (const Rational & rhs); friend bool operator == (const Rational & lhs , const Rational & rhs); private: int numer; int denom; } bool operator == (const Rational & lhs , const Rational & rhs) { return ( lhs. numer * rhs. denom == lhs. denom * rhs. numer); }

Overloading << as a friend class Rational { Rational (int , int); const Rational & operator = (const Rational & rhs); const Rational & operator + (const Rational & rhs); friend ostream & operator << (ostream & ostr , const Rational * rhs); private: int numer; int denom; } ostream & operator << (ostream & ostr , const Rational * rhs) { ostr << “numerator = “ << rhs. numer << “ denominator = “ << rhs. denom; }

More Overloading Thoughts • = overload as a member function • == != <= >= < > overload as a member • >> << (insertion and extraction) overload as non-members (friends) returning type iostream • +-*/% (arithmetics) overload as members • += -=. . . overload same as + and -

Please note: • The only operators that cannot be overloaded are –. (dot operator) –. * (pointer-to-member) – sizeof – ? : (three operands)

• Only existing operators can be overloaded. • new operators cannot be created (have to be made a named function member)