#include <iostream>

class BaseClass
{
     public:
     void myFunc()  //Can't be overridden, can be overloaded.
     {
         std::cout << "BaseClass::myFunc() called" << std::endl;
     }
     
     virtual void myVirtualFunc() //Can be overridden, but doesn't have to be.
     {
         std::cout << "BaseClass::myVirtualFunc() called" << std::endl;
     }
     
     virtual void myPureVirtualFunc() = 0; //Must be overridden.
};

class DerivedClass : public BaseClass
{
     public:
     void myFunc()
     {
         std::cout << "DerivedClass::myFunc() called" << std::endl;
     }
     
     virtual void myVirtualFunc()
     {
         std::cout << "DerivedClass::myVirtualFunc() called" << std::endl;
     }
     
     virtual void myPureVirtualFunc()
     {
         std::cout << "DerivedClass::myPureVirtualFunc() called" << std::endl;
     }
};

int main()
{
    //BaseClass baseClass; //Can't be constructed because of pure-virtual.
    DerivedClass derivedClass;
    
    BaseClass &derivedPretendingToBeBase = derivedClass;

    derivedClass.myFunc(); //Calls DerivedClass::myFunc().
    derivedClass.myVirtualFunc(); //Calls DerivedClass::myVirtualFunc().
    derivedClass.myPureVirtualFunc(); //Calls DerivedClass::myPureVirtualFunc().
    
    derivedPretendingToBeBase.myFunc(); //Calls BaseClass::myFunc(), because it's not virtual.
    derivedPretendingToBeBase.myVirtualFunc(); //Calls DerivedClass::myVirtualFunc(), because it IS virtual and overridden.
    derivedPretendingToBeBase.myPureVirtualFunc(); //Calls DerivedClass::myPureVirtualFunc(), because it is virtual and overridden.
    
    return 0;
}