Accessing virtual base class function from a derived class

Question

1.In the main function below, why does d.foo(9.5) not select the Base::foo(double) method from the base class? Doesn't the derived class inherit that method?

2.What causes the compile error?

class Base {
public:
    virtual void foo(int){
        cout << "Base::foo(int)" << endl;
    }
    virtual void foo(double){
        cout << "Base::foo(double)" << endl;
    }
};

class Derived : public Base {
public:
    virtual void foo(int){
        cout << "Derived::foo(int)" << endl;
    }
};

void main() {
    Derived d;
    Base b, *pb = &d;

    d.foo(9);     // selects Derived::foo(int)         
    d.foo(9.5);   // selects Derived::foo(int)         
    pb->foo(9);   // selects Derived::foo(int) 
    pb->foo(9.5); // selects Base::foo(double)  

    Derived * d; 
    d->foo(9);    // compile error
}

Answer 1

The compilation error is because of two variables with the same name in main().

As to your problem with inherited functions not being called for an instance of your Derived (except via pointer to Base)

The standard describes the "hiding rule", which makes this happen. Essentially, member functions declared in derived classes hide inherited functions with the same name but different signature inherited from the base class. The hiding rule is independent of whether the inherited functions are virtual or not.

The common solution is to introduce all inherited functions from the base class with using Base::foo. For example,

class Base {
public:
    virtual void foo(int){
        cout << "Base::foo(int)" << endl;
    }
    virtual void foo(double){
        cout << "Base::foo(double)" << endl;
    }
};

class Derived : public Base {
public:
    using Base::foo;
    virtual void foo(int){
        cout << "Derived::foo(int)" << endl;
    }
};

Another solution is to remember to explicitly override all inherited versions of the function (implement the derived class version to simply call the base class version of each function). This works with older compilers that do not support a using directive like the above. The catch is that it is necessary to explicitly do this with every inherited overload, and it is easy to miss one.

Answer 2

In the main function below, why does d.foo(9.5) not select the Base::foo(double) method from the base class? Doesn't the derived class inherit that method?

Yes, but it's hidden by the function with the same name in the derived class. You can unhide it with a using-declaration in the derived class:

using Base::foo;

What causes the compile error?

You're trying to declare a second variable called d. Change the name to something that's not already used; and initialise it to point to a valid object, otherwise you'll have a runtime error or other undefined behaviour.

Derived * pd = &d; 
pd->foo(9);    // selects Derived::foo(int) 

Also, main has the wrong return type. It must return int.