does pointer "this" in c++ support virtual mechanism?

Question

Consider that:

class B {
    void f() { vf(); };
    virtual void vf();
};

class D: public B{
    virtual void vf();
};

I thought that in C++ the implementation of B::f() is something like that:

f(B *this) {
    *(this->vptr[index])(this);
}

Is D::vf() called through the virtual mechanism in the following example?

B *p = new D();
p->f(); 

Answer 1

Answer is yes for the given example, but not for calls from a constructor of the base class, which executes before the derived class gets constructed.

With a slightly modifed example:

#include <iostream>

class B {
public:
    B() { f(); }

    void f() { vf(); };
    virtual void vf()  { std::cout << "B::vf" << std::endl; }
};

class D: public B{
    void vf() override { std::cout << "D::vf" << std::endl; }
};

int main()
{
    B *p = new D();  // calls D::D() --> B::B() --> B::f() --> B::vf()
    p->f();          // calls B::f() --> D:vf()
}

The output is:

B::vf
D::vf

Answer 2

I thought that in C++ the implementation of B::f() is something like that:

f(B *this) {
    *(this->vptr[index])(this);
}

The value of index is always known at compile time. The vtable is a "record" (a structure, like a C/C++ struct) rather than an array or "table". So it's like:

void f(B *This) {
    (This->vptr.ptr_f)(This);
}

Note: You don't need to dereference a pointer to function in either C or C++.

Is D::vf() called through the virtual mechanism in the following example?

B *p = new D();
p->f();

It depends on the compiler and its "intelligence". At low optimization level, it will go through the virtual mechanism (aka dynamic dispatch).

With an efficient optimizer, the real type of the object used (here D) can be determined, and dynamic dispatch can be avoided.