重载虚拟函数并通过指向基类的指针调用派生函数

Question

#include <bits/stdc++.h>
using namespace std;

class Base {
  public:
  virtual int function() const {
    cout << "Base::function()\n";
    return 1;
  }
  virtual void function(string) const {}
};


class Derived : public Base {
  public:
       // overloading function() of base
       int function(int) const {
         cout << "Derived::function()\n";
         return 4;
    }
};


int main()
{
    string s("StackOverflow");
    Derived d;
    Base* b = &d;
    //calling derived::function() and function(s)    
    b->function();
    b->function(s);
}

Because of overloading, name hiding occour in derived class.
Because of keyword virtual at runtime Derived::function() should be called.

But the code compiles successfully. link : http://ideone.com/fbVm0P
What is the reason for this strange behaviour?
EDIT 1:

d.function();  
d.function(s);  

do not compile,as expected.

Answer 1

Overload resolution uses the static types (not that it would make a difference here). So both b->function() and b->function( s ) resolve to Base::function , with no error. Finally, since these functions have been declared virtual , the final resolution will take into account any overloads in a derived class. But there aren't any, so the function in the base class will be called.

Name hiding occurs during name lookup, which is before overload resolution, and also only concerns the static type; in an expression like b->function() or b->function( s ) , the compiler ignores Derived completely; it does the name lookup on the static type. Name hiding would only come into consideration is the static type were Derived ; once the compiler found function in Derived , it would look no further.

The global rules are fairly simple: name lookup (using static type), then overload resolution (using static type), and finally, if the resolved name is a virtual function, dynamic determination of the actual function depending on the dynamic type.

Answer 2

There is no int function() const in the derived class.

Use the override keyword to avoid surprises like this, ie,

class Derived
    : public Base
{
public:
    // not overriding function() of base
    auto function(int) const
        -> int override // This won't compile, because it doesn't override.
    {
         cout << "Derived::function()\n";
         return 4;
    }
};