cs 240 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
CS-240 PowerPoint Presentation
Download Presentation
CS-240

Loading in 2 Seconds...

play fullscreen
1 / 17

CS-240 - PowerPoint PPT Presentation


  • 104 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'CS-240' - eden


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
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 overloading1
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 overloading2
Operator Overloading
  • Three basic ways:
    • as a free function (not part of a class)
    • as a member function
    • as a friend function
operator overloading3
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 member1
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 member2
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 friend1
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)