Virtual Methods

Simple Is-A Relationship Is Not Enough

code/inher-oo-derived-novirtual-base-usage.cpp

#include <iostream>


class Base
{
public:
    void method() const
    {
        std::cout << "Base::method()" << std::endl;
    }
};

class Derived : public Base
{
public:
    void method() const
    {
        std::cout << "Derived::method()" << std::endl;
    }
};

int main()
{
    Derived d;
    Base* b = &d;     // <--- **is-a**: Derived is converted to Base, **without** a cast
    b->method();      // <--- **Question**: Base::method() or Derived::method()?
    
    return 0;
}

$ ./inher-oo-derived-novirtual-base-usage
Base::method()

Questions

• If Base* b actually points to a Derived object, why isn’t Derived::method() called?

• If Derived is-a Base, how do I use it as-a Base?

• In other words: how to I use a Base* to call Derived::method()

Usage Scenario

• Consider a system that uses thermometers to measure temperature

• There are a million of different thermometers out there that can answer me that question: what’s the temperature?

• In software, I don’t want to care

  • I only want to know the temperature

  • I don’t want to expose the physics of thermometers to my system

Enter virtual

Answer

• Use virtual on those methods that need dynamic dispatch

• ⟶ through the Base*, the actual dynamic type is determined

code/inher-oo-derived-virtual-base-usage.cpp

#include <iostream>


class Base
{
public:
    virtual void method() const
    {
        std::cout << "Base::method()" << std::endl;
    }
};

class Derived : public Base
{
public:
    virtual void method() const
    {
        std::cout << "Derived::method()" << std::endl;
    }
};

int main()
{
    Derived d;
    Base* b = &d;
    b->method();       // <--- **dynamic dispatch**: calling Derived::method()!
    
    return 0;
}

$ ./inher-oo-derived-virtual-base-usage
Derived::method()

Question

• Why isn’t that the default?

Answer

• Performance ⟶ indirect function call cannot be default

Caution: virtual

• C++ lets you complete freedom

• virtual is just a mechanism to achieve dynamic dispatch

• ⟶ no policy!

• If you want to use Base* polymorphically, this is the place where virtual is written

Wrong

• virtual has to come at dynamic dispatch entry point!

code/inher-oo-derived-virtual-base-usage-wrong.cpp

#include <iostream>


class Base
{
public:
    void method() const       // <--- ERROR: virtual omitted -> **no dynamic dispatch**
    {
        std::cout << "Base::method()" << std::endl;
    }
};

class Derived : public Base
{
public:
    virtual void method() const
    {
        std::cout << "Derived::method()" << std::endl;
    }
};

int main()
{
    Derived d;
    Base* b = &d;
    b->method();              // <-- WRONG: calling Base::method()!
    
    return 0;
}

$ ./inher-oo-derived-virtual-base-usage-wrong
Base::method()

Obscure but correct

• virtual at dynamic dispatch entry point is sufficient

• ⟶ propagates down the line

• Not quite readable though

code/inher-oo-derived-virtual-base-usage-obscure.cpp

#include <iostream>


class Base
{
public:
    virtual void method() const
    {
        std::cout << "Base::method()" << std::endl;
    }
};

class Derived : public Base
{
public:
    void method() const       // <--- virtual omitted: correct but less readable
    {
        std::cout << "Derived::method()" << std::endl;
    }
};

int main()
{
    Derived d;
    Base* b = &d;
    b->method();              // <-- correct: calling Derived::method()
    
    return 0;
}

$ ./inher-oo-derived-virtual-base-usage-obscure
Derived::method()