Überladene Funktionen sind in der abgeleiteten Klasse verborgen

Question

In einer abgeleiteten Klasse Wenn ich einen Funktionsnamen aus einer Base-Klasse,
, neu definieren/überladen, sind diese überladenen Funktionen nicht zugänglich/sichtbar für abgeleitete Klasse.
Warum ist das ??

Wenn wir die oveloaded Funktion von der Basisklasse nicht dann in abgeleiteten Klasse überlasten alle überladenen Versionen dieser Funktion abgeleiteten Klasse
Objekte verfügbar sind, warum ist das ??
Was ist der Grund dafür? Wenn Sie dies im Compiler und Linker Ebene
erklären, die für mich hilfreicher sein wird. Ist es nicht möglich, diese Art von Scinario zu unterstützen?

Edited 
For examble: 

class B 
{ 

    public: 
    int f() {} 
    int f(string s) {} 
}; 

class D : public B 
{ 
    public: 
    int f(int) {} 
}; 

int main() 
{ 
    D d; 
    d.f(1); 
    //d.f(string); //hidden for D 
} 

Now object 'd' can't access f() and f(string).

Answer 1

TTBOMK dies keinen wirklichen technischen Grund hat, es ist nur, dass Stroustrup, wenn die Sprache zu schaffen, dies als die bessere Verzug. (. Dabei ist es ähnlich wie bei der Regel, dass rvalues ​​implizit nicht an nicht-const Referenzen binden)

Sie können um es leicht arbeiten explizit Versionen Basisklasse in der abgeleiteten Klasse werden zu bringen Anwendungsbereich:

class base { 
public: 
    void f(int); 
    void g(int); 
}; 

class derived : public base { 
public: 
    using base::f; 
    void f(float); 
    void g(float); // hides base::g 
}; 

oder durch die expliziten Aufruf:

derived d; 
d.base::g(42); // explicitly call base class version 

Answer 2

die Funktionen stehen zur Verfügung, Sie müssen nur sie explizit nennen:

struct A { 
    void f(){} 
}; 

struct B : public A { 
    void f() {} 
}; 

int main() { 
    B b; 
    b.f();  // call derived function 
    b.A::f(); // call base function 
}