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

Overloading Operators in General (continued)

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

Static Members

• If a class data member or member function is declared with the static keyword, then that member is a static member.

• If a class A has a static member M, then all instances of A share the same M. There is not one M for each instance, like there would be for nonstatic members.
  • Static members belong to the class, not to the individual instances.

• A static function can be called even if no instances exist.
  • To specify the name of the static member function, we must qualify it using the name resolution operator and the name of the class.

• Example: Suppose we have a person class which represents a person. It stores a person's name and weight (in kilograms). We want to be able to output the person's weight in either kilograms or pounds, so we will use a boolean value which will be shared by all instances of person.

     class person {
        public:
           int getWeight() const;
           static void setUnits(boolean kilograms);
           ...
        private:
           static bool kgs;
           ...
        };
  
     ...
  
     int person::kgs = true;
  
     ...
     
     int main() {
        ...
        person::setUnits(true);
        ...
        person p;
        cout << p.getWeight();
        ...
        p.setUnits(false);    // changes "kgs" for all persons, not just p.
        ...
     }
           

Return to lecture notes index

Lectures