Overloading a method in a subclass in C++

Suppose I have some code like this:

class Base {
    public:
      virtual int Foo(int) = 0;
};

class Derived : public Base {
    public:
      int Foo(int);
      virtual double Foo(double) = 0;
};

class Concrete : public Derived {
    public:          
      double Foo(double);
};

If I have a object of type Concrete, why can I not call Foo(int)?

If I change the name of Foo(double) so that it isn't o开发者_高级运维verloading Foo, then all is well and both methods are accessible, but this isn't what I want.

Similarly, if I remove Concrete class and implement Foo(double) in Derived, then both are accessible, but again, not what I want.

Name lookup happens before overload resolution, so once Foo has been found in Concrete, base classes won't be search for other methods called Foo. int Foo(int) in Derived is hidden by the Foo in Concrete.

You have a number of options.

Change the call to be explicit.

concrete.Derived::Foo(an_int);

Add a using declaration to Concrete.

class Concrete : public Derived {
public:          
   using Derived::Foo;
   double Foo(double);
};

Call the function through a base reference.

Derived& dref = concrete;
dref.Foo(an_int);

Foo(double) hides the function from your base. You can make it visible though:

class Concrete : public Derived 
{
public:          
  using Derived::Foo;
  double Foo(double);
};