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

Overloading the Output Operator (continued)

• (continued)
  • 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;
    	       

  • Unary prefix global operator:

       const myClass1& operator++(const myClass1& onlyOp);
       ...
       myClass1 a;
       ...
       ++a;
    	       

  • Unary prefix member operator (the operand is the instance for which the function is called):

       const myClass1& myClass1::operator++();
       ...
       myClass1 a;
       ...
       ++a;
    	       

  • Unary postfix global operator:

       const myClass1& operator++(const myClass1& onlyOp, int i);
       ...
       myClass1 a;
       ...
       a++;
    	       

  • Unary postfix member operator (the operand is the instance for which the function is called):

       const myClass1& myClass1::operator++(int i);
       ...
       myClass1 a;
       ...
       a++;
    	       

  • Note the int parameter in the definition of the unary postfix operators. This parameter is never used in the function and never passed when the function is called. It is only used to indicate to the compiler that the operator is postfix.

Friend Functions and Classes

• Problem: Sometimes it is not possible to encapsulate an abstraction in a single class. We may require more than one class or a class with some global functions. How can we allow closely related classes and functions to cooperate?

• Solution: Use friend functions and classes.

• Friendship is a feature that enables a class to grant access to its private members to a few specific functions and classes.
  • If class A declares function f and class B to be friends, then function f and class B can access the private members of A.

• It is common to make the overloaded operators << and >> friends, since they must have access to the private members of the class they are inputting or outputting and they cannot be member functions of that class.

• Example of a friend function:

     class sentence {
        public:
  	 friend ostream& operator<<(ostream& os, const sentence& s);
        ...
        };
  	 
      ostream& operator<<(ostream& os, const sentence& s) {
         ...
      }
  	 

  • Note that the friend keyword appears only in the class definition, and not with the function definition.

  • A function can be a friend of more than one class.

• Example of a friend class:

     class A {
        ...
        };
  
     class B {
        public:
  	 friend class A;
        ...
        };
  	 

• Example of mutially friendly classes:

     class A;
  
     class B {
        public:
  	 friend class A;
        ...
        };
  
     class A {
        public:
  	 friend class B;
        ...
        };
  	 

• The friend declaration can appear anywhere in the class definition, but I think it makes sense to put it in the public area.

• Friendship can never be taken. It can only be granted.

Return to lecture notes index

Lectures