Il sovraccarico di un metodo in una sottoclasse in C++

Question

Supponiamo che io sono un po 'di codice come questo:

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

Se ho un oggetto di tipo concreto, perché non posso chiamare Foo (int)?
Se cambio il nome di Foo (double) in modo che non stia sovraccaricando Foo, allora tutto va bene ed entrambi i metodi sono accessibili, ma questo non è quello che voglio.
Analogamente, se rimuovo la classe Concrete e implemento Foo (double) in Derived, entrambi sono accessibili, ma, di nuovo, non quello che voglio.

Answer 1

Nome ricerca avviene prima risoluzione di sovraccarico, quindi una volta Foo è stato trovato in Concrete, classi di base non sarà la ricerca di altri metodi chiamati Foo. int Foo(int) in Derived è nascosto dallo Foo in Concrete.

Hai un numero di opzioni.

Modificare la chiamata in modo esplicito.

concrete.Derived::Foo(an_int); 

Aggiungere una dichiarazione utilizzando per calcestruzzo.

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

Chiamare la funzione tramite un riferimento di base.

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

Answer 2

Foo(double) nasconde la funzione dalla base. Si può rendere visibile però:

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