CS-240: CS-240 Operator Overloading
Dick Steflik
Operator Overloading: 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: 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: Operator Overloading Three basic ways:
as a free function (not part of a class)
as a member function
as a friend function
Operator Overloading: 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: 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: 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 : 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: 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: 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 (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): 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: 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: 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: 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:: Please note: The only operators that cannot be overloaded are
. (dot operator)
.* (pointer-to-member)
sizeof
?: (three operands)
Slide17: Only existing operators can be overloaded.
new operators cannot be created (have to be made a named function member)