overloaded functions are hidden in derived class



In a derived class If I redefine/overload a function name from a Base class,
then those overloaded functions are not accessable/visible to derived class.
Why is this??

If we don't overload the oveloaded function from the base class in derived class then all the overloaded versions of that function are available to derived class
objects, why is this??
what is the reason behind this. If you explain this in compiler and linker level
that will be more helpful to me. is it not possible to support this kind of scinario??

For examble:

class B  

     int f() {}
     int f(string s) {}

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

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

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

2 Answers: 

TTBOMK this doesn't have a real technical reason, it's just that Stroustrup, when creating the language, considered this to be the better default. (In this it's similar to the rule that rvalues do not implicitly bind to non-const references.)

You can easily work around it be explicitly bringing base class versions into the derived class' scope:

class base {
  void f(int);
  void g(int);

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

or by calling the explicitly:

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

The functions are available, you just need to call them explicitly:

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