Does a VTBL contains pointers to non-virtual functions?

Question

I'm having hard time to understand why the code below print C::f2 instead of B::f2.

From Charles Bailey answer:

When a non-virtual function is called the implementation must use the static type of the object on which the function is being called to determine the correct function to call. A function stored in a vtable accessed by a vptr will be dependent on the dynamic type of the object, not any static type of a reference or pointer through which it is being accessed.

I'm a bit lost, Inside A::f1 there is a call to f2. How does the compiler know which method to call?

My assemption:

1. The compiler somehow remmber that we are inside object of type C.
2. The compiler check if C contain a non virtual method name f2. a. if yes, run it. b. use the object's pointer to access his vtbl and run the right f2.

Am I right?

struct A
{
    void f1()
    {
        f2();
    }
    virtual void f2()
    {
        cout<<"A::f2"<<endl;
    }
};
struct B:public A
{
    virtual void f2()
    {
        cout<<"B::f2"<<endl;
    }
};
struct C:public B
{
    void f2()
    {
        cout<<"C::f2"<<endl;
    }
};
int main()
{
    C c1;
    c1.f1();
    return 0;
}

Answer 1

Every member function has an implicit this parameter. The static type of this inside f1 is always A * const. This is true for any member function. The static type of the implicit object parameter is the enclosing class where the function is defined.

The call inside f1 is resolved as this->f2(). Since this is a call via pointer, the function f2 is dispatched dynamically. This is despite the fact the f1 is not virtual, and will always be called by static dispatch.

By whatever mechanism the compiler uses (a VTable is an implementation detail, not mandated by the C++ standard itself), we get a call to C::f2.

So your assumptions need some revision, I'd say.

---

To answer your question as you specified in the comments. C::f2 is virtual. You may have omitted the virtual specifier when overriding it, but there is no "unvirtualising" it.