Question

From http://www.learncpp.com/cpp-tutorial/125-the-virtual-table/, code such as

class Base
{
public:
    virtual void function1() {};
    virtual void function2() {};
};

class D1: public Base
{
public:
    virtual void function1() {};
};

class D2: public Base
{
public:
    virtual void function2() {};
};

generates a virtual table similar to http://www.learncpp.com/images/CppTutorial/Section12/VTable.gif:

The virtual table as above makes sense. After all the objects need a way to call functions, and need to use function pointers to find them.

---

What I do not understand is why this is only required in case of using virtual functions? I am definitely missing something since a virtual table does not directly depend on virtual functions.

As an example, if the code being used were

class Base
{
public:
    void function1() {};
    void function2() {};
};

...

Base b;
b.function1();

and there is no virtual table (meaning there is no pointer to where the function resides), how would the b.function1() call resolve?

---

Or is it that we have a table in this case as well, just that it is not called a virtual table? In that case the question would arise as to why we need a new kind of table for virtual functions?

Answer 1

[If] there is no virtual table (meaning there is no pointer to where the function resides), how would the b.function1() call resolve?

There is a “pointer”, inside the compiler as it’s parsing and analysing your code. The compiler’s the thing that decides where the function will be generated, so it knows how calls to said function should resolve. In concert with the linker, this all happens tidily within the build process.

The only reason that this doesn’t work for virtual functions is that which function you call depends on a type known only at runtime; in fact the same function pointers are present verbatim in the virtual table, written there by the compiler. It’s just that in this case, there are multiple to choose from, and they cannot be chosen from until long (read: potentially months or even years!) after the compiler ceases to be involved at all.