Why must I scope an overloaded template base class method?

Question

I can't seem to call a method of a base class without scoping to the base class, and it seems that this is because I have overloaded the method. If I do not overload the method then the compiler doesn't complain. Here's an example of what I'd like to do:

struct BaseClass {                                                           
  template <typename T> T& foo(T& t) {                               
    return t;                                                                
  }                                                                          
};                                                                           

class ChildClass: public BaseClass {                                         
  public:
  // The presence of this template causes compiler confusion                                                            
  template <class T> T& foo(T& t, int szl) {                        
    return t;                                                                
  }                                                                          

  template <class T> int bar(T& t) {                 
    // But if I scope this as BaseClass::foo(...) it's all good                        
    return foo(t);                                                
  }                                                                          
};                                                                           

int main() {                                                                 
  int t = 1;                                                                 
  ChildClass c;                                                              
  c.bar(t);                                        
}

If in bar(...) I call BaseClass::foo(...) the compiler does not complain, but I don't see any ambiguity here and so I'm confused as to why I'd need to do this.

Answer 1

When the compiler tries to match a function name with a function, it does so in two steps. In the first step it finds all the functions that match the given name. If it finds more than one function, it tries the logic of overload resolution to find the best matching function.

In the first step, if the compiler finds a name in the class, it stops looking for functions of the same name in base classes. In your case, since it finds a foo in ChildClass, it stops searching for functions named foo in BaseClass. However, the only matching foo does not match the call and the compiler reports an error.

How to resolve the problem:

1. Use the method you described in your post. Call BaseClass::foo(...).

2. Bring all the foo from BaseClass into the scope of ChildClass.

   class ChildClass: public BaseClass {
     public:
   
     using  BaseClass::foo;
   
     template <class T> T& foo(int baz, T& t, int szl) {
        return t;
     }
   
     template <class T> int bar(T& t) {
       return sizeof(foo(1, t)); // Should work.
     }
   };