How can a member function in my derived class call the same function from its base class?

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...

 

 void mycode(Fred* p)
 {
   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):

 

 void mycode(Fred* p)
 {
   __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:

 

 void Der::f()
 {
   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):

 

 void __Der__f(Der* this)   ← pseudo-code only; not real
 {
   __Base__f(this);         ← pseudo-code only; not real
 }