Well, technically…

Suppose we have an instance of MoreDerived, and we call the member function g on it. Which f gets called, and what syntax do we need in g to call the other f’s?

// test.cc

void f();

template< class T >
class Base
{
public:
    virtual void f();
};

template< class T >
class Derived : public Base< T >
{
public:
    void g()
    {
        f();    // which f does this call?
    }
};

class MoreDerived : public Derived< int >
{
    void f();
};

The answer is that it calls the global function f. The reason (or ‘problem’) is that in the expression “f();”, the identifier f is a non-dependent name. It does not depend on the template parameter, so lookup occurs at the point of definition of g, not at the point of instantiation of the template. Because the base class is dependent on the type of the template parameter it is not used to resolve f. The only visible f is, therefore, the global f.

To call the base class’ f, we just use a qualified identifier:

void g()
{
    Base<T>::f();
}

As usual, this disables the virtual function mechanism and a direct call to the base class’ f is made.

How do we ensure that the correct virtual f is called? We need to call f through a pointer or reference which is dependent on the template parameter so that the base class is used in the lookup of f at the point of instantiation.

This means something like:

void g()
{
    Base<T>& baseref = *this;
    basethisref.f();
}

or

void g()
{
    Base<T>* basethis = this;
    basethis->f();
}

It’s actually enough to just do this:

void g()
{
    this->f();
}

“this” is type-dependent because g is a member function of a class template, so “this->f()” is a type-dependent expression because it has “this” as a type-dependent subexpression.