Base class template member function shadowed in Derived class, albeit different parameter list

Question

This has me wondering. Suppose I have :

class Base
{
public:

    template<typename T>
    void foo(T& varT)
    {
        //
    }

    template<typename T, typename U>
    void foo(T& varT, U& varU)
    {
        //
    }
};

class Child : public Base
{
public:
    template<typename T, typename U, typename Z>
    void foo(T& varT, U& varU, Z& varZ)
    {
        //
    }
};

Now when I try this:

Child c;

char cVar;
int iVar;
float fVar;

c.foo(cVar);
c.foo<int>(cVar);
c.template foo<int>(cVar);

None of the calls work. They are always shadowed with error 'No matching member function for call'. Can anybody point me to a way to resolve this? I read in the standard that derived objects shadow template functions inherited but the standard explicitly said that the parameter list must be the same if they are shadowed.

Appreciate the help.

Answer 1

Hiding base members always happens when you have a name in a derived class that is present in a base class. The basic reason is that it is desirable to guard derived class uses against changes in the base class: assuming names from bases were not hidden, if a new overload in a base class is added a working look-up to a derived member may be hijacked to rather refer to the base class without any indication in the derived class that something may happen in the base class. If you mean to make the base members available, you can use a using declaration:

class Child : public Base
{
public:
     using Base::foo; // declare that you want look up members from the base class

     template<typename T, typename U, typename Z>
     void foo(T& varT, U& varU, Z& varZ)
     {
         //
     }
};

In your code you had three calls:

1. c.foo(cVar) works with the using declaration.
2. c.foo<int>(cVar) doesn't work even with the using declaration because you can't bind a non-const reference to int to a char lvalue. Using c.foo<char>(cVar) would work.
3. c.template foo<int>(cVar) suffers from the same problem. Since c is clearly not a dependent name, there is no need at all to use template in this context.

Without the using declaration you can call the member by qualifying the call explicitly, e.g.:

c.Base::foo(cVar);