Virtual

• What does virtual do?
• Without virtual we can think of functions in a hierarchy like variables in functions

  • int w;
    void function () {
    
         int x;
         int y;
     
         x = y;
     
         while () {
             int x;
             int z;
     
             y = z;
             x = z;
             w = z;
        }
     } 

  • What x and y are referred to on line 4.
  • How about on line 10 and 11?
  • The names are just hidden.
    • The compiler resolves the issue by searching the different scopes.
• The same is true with hierarchical classes.

  • 
     class Base {
        public:
           Method1();
           Method2();
    };
    
    class Derived: public Base {
        public:
           Method1();
           Method3();
    }
    
    Base * b;
    Derived * d = new Derived;
     b = d;
    
    d->Method1();
    d->Method2();
    d->Method3();
     
    b->Method1();
    b->Method2();
    b->Method3();
    
     b = new Base;
    
    d->Method1();
    d->Method2();
    d->Method3();
     
    b->Method1();
    b->Method2();
    

  • At compile time, the compiler searches to for the right function to link to.
  • It does this based on the type at compile time.
  • Line 17-19 do what you expect
  • Line 21 calls the base method.
  • Line 23 is an error.
  • Line 29 is a problem
• However virtual changes when the binding occurs.
  • When a function is declared virtual, the class gains an associated table.
  • This table has a pointer for any virtual functions to the correct implementation.
  • 
  • The table is created when the object is created
    • IE, the pointers are right for the type created.
  • When a virtual function is called, the address is looked up in this table.
• One more thing
  • virtual void myfunc() = 0;
  • This is pure virtual function.
  • It says that derived classes must implement this function
  • But the base class refuses to .
  • This makes the base class an abstract base class.
  • And abstract base classed can not be instantiated.
• There are several differing views on what to do with virtual.
  • Make your destructor virtual period
  • Do not make your constructor virtual period.
  • Gregorie says to make everything else virtual.
    • This allows you to override everything.
    • But it costs a little bit of computation.
  • Meyers says
    • A pure virtual function provides a required interface.
    • A virtual function provides both an interface and a default behavior, but either can be overridden.
    • A non-virtual function provides functionality.
• Meyers has quite a few points here
  • Item 32. Make sure inheritance modes "is-a"
    • He uses the example of a bird and a penguin

    • class Bird {
          public: 
              virtual Sing();
              virtual Fly();
      };
      
      class Penguin: public Bird {
      }; 

    • Here a penguin can fly.
    • This is because Bird has a Fly method, but not all birds can fly
    • The solution is.

    • class Bird {
          public
              virtual Sing();
              ...
      };
      
      class FlyingBird: public Bird{
          public: 
              virtual Fly();
      }
      
      class Penguin: public Bird {
      }; 

    • The base class is a generic representation.
      • Everything that inherits from the base class must do what the base class does.
      • Everything that inherits from the base class specializes what the base class does.
    • His example a student is a human.
      • Students do everything humans do.
      • Plus some more.
• If any method of an overloaded method is overridden, other methods are hidden
• See pure.cpp and slice.cpp if we have not yet looked at them.