CMPT 212 Object-Oriented Applications Design in C++ Spring 1998

Overloading the Assignment Operator (continued)

• When we use the overloaded assignment operator, we are actually calling the member function that we defined.
  • Example:

       sentence a;
       sentence b;
       ...
       a = b;               //  These two lines are
       a.operator=(b);      //  the same.
                   

• The pointer this is automatically defined in member functions.
  • It points to the the instance for which the member function is being called.

  • The if statement is used so that a=a works correctly.

• It is common for the assignment operator to return a reference to the instance being initialized.
  • Then we can do multiple assignments or use the assignment in conditional expressions. But just because we can doesn't mean that we should. Your code should be very readable.

  • Example:

       sentence a;
       sentence b;
       sentence c;
       ...
       a = b = c;
       ...
       while ((a = readSentence()) != badSentence) {
          ...
          }
                   

• The parameter to the assignment operator is usually defined to be const because we normally don't want to change it.
  • There may be a rare case where you must change it, but this should be carefully documented.

Overloading the Output Operator

• We can overload the << operator for our own classes.

• Example:

     ostream& operator<<(ostream& os, const sentence& s) {
        os << *(s.words);
        return os;
     }
           

• The class ostream is defined in the file <iostream.h>. cout is an instance of ostream. cout is also defined in <iostream.h>.

• The << operator is not a member of any class.
  • When we call it, the left operand is the first parameter and the right operand is the second parameter.

  • Example:

       sentence a;
       cout << a.               //  These two lines are
       operator<<(cout, a);     //  the same.
                   

  • In order for the << operator to have access to the private members of a sentence, it must be a "friend" function. We will cover friend functions soon.

• The << operator returns a reference to an ostream so that we can use it in a compound output statement.
  • Example:

       sentence a;
       int      i;
       float    f;
    
       cout << i << a << f;         //  These two lines are
       ((cout << i) << a) << f;     //  the same.
    	       

  • The return reference must be to a non-const instance since further output will change the instance.

Overloading the Input Operator

• Overloading the >> operator is very similar to overloading the << operator.

• Example:

     istream& operator>>(istream& is, sentence& s) {
        ...
        return is;
     }
           

Overloading Operators in General

• You can overload binary operators or unary operators.
  • Note that unary operators can be prefix (for example, ++i) or postfix (for example, i++).

• The overloaded operator can be defined as a global function or as a class member function.

• Here is a brief summary of how the different kinds of operators are defined. (You may not want all of the consts that are shown.)
  • Binary global operator:

       const myClass1& operator+(const myClass2& leftOp, const myClass3& rightOp);
       ...
       myClass1 a;
       myClass2 b;
       myClass3 c;
       ...
       a = b + c;
    	       

  • Binary member operator (the left operand is the instance for which the function is called):

       const myClass1& myClass2::operator+(const myClass3& rightOp);
       ...
       myClass1 a;
       myClass2 b;
       myClass3 c;
       ...
       a = b + c;
    	       

Return to lecture notes index

Lectures