Why is not overloaded function for derived class o

问题:

In the following code

#include <iostream>
using namespace std;

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

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

void process(const A&) {
    cout << "processing A" << endl;
}

void process(const B&) {
    cout << "processing B" << endl;
}

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

the output of running it becomes

processing A

but I would have assumed that it should have been

processing B

since a points to the derived class B and not A. So why does it call the first implementation of process function and not the second?

回答1:

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.

回答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&).

回答3:

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.