CMPT 212 Object-Oriented Applications Design in C++ Fall 1997

Classes with Pointers to Dynamic Memory (continued)

• (continued)
  • The copy constructor solves this problem:

       sentence first = oldSentence;      //  These two lines do the
       sentence first(oldSentence);       //  same thing.
                   

    but it does not solve this one:

       sentence first;
       first = oldSentence;      //  Initialize an existing instance.       
                   

    For this we need operator overloading.

Operator Overloading

• Many operators in C++ are already overloaded.
  • Examples:
    • There is a + for ints and a + for floats.

    • There is a = for almost every type.

    • There is a << for many types.

• We can overload many of the operators with our own definitions. (See Table 10-1, page 413, in Prata.)
  • We cannot create new operator symbols.

  • We cannot overload sizeof, ., .*, ::, or ?:.

  • At least one operand must be a user-defined type, so we cannot redefine operators for standard types.

  • We cannot change the precedence of operators.

• The most common operators to overload are =, <<, and >>.

Overloading the Assignment Operator

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

• Example:

     const sentence& sentence::operator=(const sentence& s) {
        if (this != &s) {
           delete [] words;
           words = new char[strlen(s.words) + 1];
           strcpy(words, s.words);
           count = s.count;
           }
        return *this;
     }
           

• The assignment operator function looks like the copy constructor.
  • They both set the value of an instance by using an existing instance.

  • The copy constructor is used when a new instance is being created.

  • The assignment operator is used to set the value of an existing instance.

• 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.
                   

Return to lecture notes index

Lectures