CS-240 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.

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 getNumer() const { return numer; } int getDenom() 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 r1, r2; r1 = r2; -note: the if statement catches the special case where someone is trying r1=r1, the if statement makes the code faster

Overloading + as a member const Rational 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.getDenom() * rhs.getNumer() == lhs.getNumer() * rhs.getDenom()); } Rational r1, r2; if ( r1 == r2 ) cout……… else cout

Overloading == as a member const bool Rational::operator == (const Rational & rhs ) { return ( numer * rhs.denom == denom * rhs.numer); } Rational r1, r2 ; if (r1 == r2 ) 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)