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 than 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
 }