C++ FAQ Celebrating Twenty-One Years of the C++ FAQ!!!
(Click here for a personal note from Marshall Cline.)
Section 20:
[20.5] 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
}