Grandparent overloaded function in child [duplicate]

Question

I need to understand why C++ don't allow to access Grandparent overloaded functions in Child if any of the overloaded function is declared in Parent. Consider the following example:

class grandparent{
public:
    void foo();
    void foo(int);
    void test();
};

class parent : public grandparent{
public:
    void foo();
};

class child : public parent{
public:
    child(){
        //foo(1); //not accessible
        test();   //accessible
    }
};

Here, two functions foo() and foo(int) are overloaded functions in Grandparent. But foo(int) is not accessible since foo() is declared in Parent (doesn't matter if it declared is public or private or protected). However, test() is accessible, which is right as per OOP.

I need to know the reason of this behavior.

Answer 1

The reason is method hiding.

When you declare a method with the same name in a derived class, base class methods with that name are hidden. The full signature doesn't matter (i.e. cv-qualifiers or argument list).

If you explicitly want to allow the call, you can use

using grandparent::foo;

inside parent.

Answer 2

Just imagine that a library has this class:

struct Base {
};

In your code you use that class as a base class:

struct Derived : Base {
    void f(int);
};

and now you write:

Derived d;
d.f('a');

And now you get the shiny new version 2.0 of that library, and the base class has changed a bit:

struct Base {
    void f(char);
}

If overloading applied here, your code would break.