c++ - 使用派生类重载函数

Question

我想做的是这样的:

void SomeFunction(Base *){//do something}
void SomeFunction(Derived *){//do something else}

这在 C++ 中可行吗？到目前为止，我的尝试只是调用该函数的基本版本。 为了清楚起见，这里有一个示例。

示例:

#include <iostream>
#include <vector>

class Base
{
    public:
        Base () {std::cout << "Base Constructor for " << this << std::endl;}
        void virtual PrintSomething ()
        {
            std::cout << "I am Base!" << std::endl;
        };
};

class Derived : public Base
{
    public:
        Derived () : Base () {std::cout << "Derived Construtor for " << this << std::endl;}
        void virtual PrintSomething ()
        {
            std::cout << "I am Derived!" << std::endl;
        };
};

void DoAmazingStuff ( Base * ) {std::cout << "Amazing!" << std::endl;}
void DoAmazingStuff ( Derived * ) {std::cout << "DERP!" << std::endl;}

int main ()
{
    std::vector<Base *> some_vector;

    Base *x = new Base ();
    Derived *y = new Derived ();

    some_vector.push_back ( x );
    some_vector.push_back ( y );

// This is the part that isn't functioning as expected.
/******************************************/
    DoAmazingStuff ( some_vector[0] );
    DoAmazingStuff ( some_vector[1] );
/******************************************/

    std::cin.get ();
    std::cin.get ();
    delete some_vector[0];
    delete some_vector[1];
}

永远不会调用以下行:

void DoAmazingStuff ( Derived * ) {std::cout << "DERP!" << std::endl;}

Answer 1

当然有可能；但只有当指针的静态类型为 Derived* 时，才会调用 Derived 版本。例如:

Base * b = new Base;        // static and dynamic types are Base
Derived * d = new Derived;  // static and dynamic types are Derived
Base * bd = new Derived;    // static type Base, dynamic type Derived

SomeFunction(b);   // Base overload
SomeFunction(d);   // Derived overload
SomeFunction(bd);  // Base overload (from static type)

动态调度(根据动态类型选择函数)只会在调用虚成员函数时发生，不会重载非成员函数:

struct Base {
    virtual void SomeFunction() {/*do something*/}
};
struct Derived : Base {
    virtual void SomeFunction() {/*do something else*/}
};

b->SomeFunction();  // Base version
d->SomeFunction();  // Derived override
bd->SomeFunction(); // Derived override (from dynamic type)

并且您可以在成员函数的帮助下在非成员函数上实现类似动态调度的功能:

void SomeFunction(Base * b) {b->SomeFunction();}

如评论中所述，此技术可以扩展以实现多重分派(dispatch)，根据多个函数参数的动态类型选择一个函数。但这超出了问题的范围。