Use Base::f();
Let's start with a simple case. When you call a non-virtual function, the compiler obviously doesn't use the virtual-function mechanism . Instead it calls the function by name, using the fully qualified name of the member function. For instance, the following C++ code...
{
p->goBowling(); ← pretend Fred::goBowling() is non-virtual
}
...might get compiled into something like this C-like code (the p parameter becomes the this object within the member function):
{
__Fred__goBowling(p); ← pseudo-code only; not real
}
The actual name-mangling scheme is more involved that the simple one implied above, but you get the idea. The point is that there is nothing strange about this particular case — it resolves to a normal function more-or-less like printf() .
Now for the case being addressed in the question above: When you call a virtual function using its fully-qualified name (the class-name followed by " :: "), the compiler does not use the virtual call mechanism, but instead uses the same mechanism as if you called a non-virtual function. Said another way, it calls the function by name rather than by slot-number . So if you want code within derived class Der to call Base::f() , that is, the version of f() defined in its base class Base, you should write:
{
Base::f(); ← or, if you prefer, this->Base::f();
}
The complier will turn that into something vaguely like the following (again using an overly simplistic name-mangling scheme):
{
__Base__f(this); ← pseudo-code only; not real
}