Friendship

• Not inherited
• Friend of base class is not automatically friend of derived class
• Of course, can make it so if necessary

Function Overriding

• One example of specialization of derived classes
• Redefine behavior of base class functions for derived classes
• Redefine function with same signature (return type, name, parameters, const)
• Different than function overloading (which uses same name but different signature)
• Can only be done between base and derived classes
• Provides more transparency to users

Example: override printTime instead of defining printZonedTime

class ZonedTime: public Time  {
  public:
       enum Zone  {EST, CST, MST, PST, EDT, CDT, MDT, PDT};
        ZonedTime(int h = 0, int m = 0, int s = 0, Zone z = EST);
        void setZonedTime (int h, int m, int s, Zone z);
        void printTime( ) const; // function OVERRIDING
  private:
     Zone zone;
};

 

void ZonedTime :: printTime ( ) const

{
// new code for printing hours, minutes, seconds

// or call Time :: printTime( )

// then output the zone

}

 

// main won’t call Time::printTime( ) because it’s “hidden” behind ZonedTime::printTime( )

main ( ) 
{
    ZonedTime zt (12, 0, 0); // noon, EST (default parameter)

    zt.increment ( ); // an inherited method
    zt.printTime ( ); // overridden method
}

Virtual Functions

• Superclass pointers can be assigned pointers to derived classes
      Time* t = new ZonedTime(8);
• Same for references, reference parameters
      ZonedTime zt(1,2,3);
      Time t = zt;  // zt is passed as a Time& in Time's copy constructor
• Normally, pointers to base classes won't invoke derived class methods
      Time* t = new ZonedTime(8);
      t -> printTime( );  // calls Time :: printTime ( )
• "Correct" method can be found at runtime if method is declared virtual

class Time {
    public:  // other stuff...
                virtual void printTime (  ) const;         
    private: // other stuff...
};

class ZonedTime : public Time {
    public:  // other stuff...
                void printTime (  ) const; //  New implementation will be found at runtime
    private: // other stuff...
};

    Time* t = new ZonedTime(8);
    t -> printTime( );  // calls ZonedTime :: printTime ( )

• Virtual functions
      derived classes inherit implementation, ability to override for pointers/references
      implementation for most specific type called at runtime on
           pointers/references to objects
      derived class can always fall back on implementation from base
           class (inherits base class implementation by default)
      virtual destructor should be declared when virtual functions used

• Nonvirtual functions
      derived classes inherit implementation, no ability to overrride for pointers/references
      implementation for declared type of object always called;
           normally shouldn't override these
      provides invariance over specialization

Pure Virtual Functions

• sometimes a superclass virtual function is just an interface to a subclass implementation
  class Printable {
      public:
              virtual void Print ( ) = 0;  // not implemented ("pure")
      ....                                          //   serves as interface 
  };
  class Time : public Printable {
      public:
              void Print ( );  // Time class implements Printable :: Print ( )
      ...
      };
• Printable is an abstract base class (serves as interface rather than object)
• can't instantiate such a class
• can only instantiate derived classes with all pure virtual functions implemented
• used when base class has no idea how derived classes can do the job
• if one is declared, should also declare pure virtual destructor

Types of inheritance

• We saw public inheritance above
      derived class has no access to private part of base class
      public and protected parts of base class have same access
           specifications in the derived class
• Also protected inheritance...
      derived class has no access to private part of base class
      public and protected parts of base class become protected members
          of derived class
• And private inheritance
      derived class has no access to private part of base class
      public and protected parts of base class become private parts
           of derived class
• Protected and private inheritance rarely used; hide the "is-a" relationship
• Convenient alternative to aggregation (if only one contained object needed)