0

我想做的是这样的：

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;}
4

1 回答 1

7

当然有可能；但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();}

正如评论中所指出的，这种技术可以扩展为实现多个调度，根据多个函数参数的动态类型选择一个函数。但这超出了问题的范围。

于 2013-05-31T12:08:51.000 回答