Overloading a method in a subclass in C++

Question

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 overloading 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.

Answer 1

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);
};

Answer 2

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);