Why is not overloaded function for derived class object invoked when given a pointer to base class in C++?

Question

In the following code

#include 
using namespace std;

class A {
  public:
    A() {}
    virtual ~A() {};
};

class B : public A {
  public:
             


        

Answer 1

void process(const A&); is a better (exact) match, since dereferencing A* gives you A&.

Short answer, but there isn't much more to say unless you want a reference from the standard.

You could dynamic_cast the result of *a and that would give you a B&, but that's smelly desing. What you probably want is a virtual function in A that's overriden in B (assume it's called foo). Then, calling a->foo() would dispatch to B::foo.

Answer 2

You need to make process() a virtual member function of A, B:

class A {
  public:
    A() {}
    virtual ~A() {};
    virtual void process() const { cout << "processing A" << endl; }
};

class B : public A {
  public:
    B() {}
    virtual ~B() {};
    virtual void process() const override { cout << "processing B" << endl; }
};

int main(void) {
    A* a = new B;
    a->process();
    return 0;
}

In your current code, *a is of type A&, so the closest match to process(*a); is the first overload (for const A&).

Answer 3

The static type of expression *a is A because a was declared as

A* a = new B;

The compiler resolves the selection of overloaded functions using the static type of the argument.

Even when virtual functions are called the compiler uses the static type of the object to call appropriate function. The difference is only that the compiler uses the table of pointers to virtual functions to indirectly call the required function.