Question

我最近想让c ++通过其输入参数动态解析成员/函数，该参数存在于某些派生版本中。这就是我的意思：

#include <iostream>

class Base {
};

class DerivedA : public Base {
};

class DerivedB : public Base {
};

class DerivedC : public Base {
};

class Test {
public:
    void world( DerivedA *instance )
    {
        std::cout << "DerivedA" << std::endl;
    }

    void world( DerivedB *instance )
    {
        std::cout << "DerivedB" << std::endl;
    }

    void world( Base *instance )
    {
        std::cout << "Base" << std::endl;
    }
};

int main()
{
    Base *a = new Base;
    Base *b = new DerivedA;
    Base *c = new DerivedB;
    Base *d = new DerivedC;

    Test hello;
    hello.world( a );
    hello.world( b );
    hello.world( c );
    hello.world( d );

    return 0;
}

我想要的行为是：

Base
DerivedA
DerivedB
Base

但是我肯定真的得到的输出是这样的：

Base
Base
Base
Base

据我所知，动态绑定是另一种方式，在派生类的基础中解析正确的成员函数而不是那样 - 但它能以任何方式工作吗？

也许我只是错过了重要的一点......

然而，非常感谢提前！

塞巴斯蒂安

Answer 1

a，b，c和d的类型均为Base*。编译器不跟踪“变量包含的内容”。如果这是你想要做的，那么你需要在你派生的类中使用虚函数，例如：

class Base {
 public: 
   virtual const char* MyName() { return "Base"; }
};

class DerivedA : public Base {
 public: 
   virtual const char* MyName() { return "DerivedA"; }
};
... similiar for all derived classes ... 

void world( Base *instance )
{
    std::cout << instance->MyName() << std::endl;
}

（编辑：要准确获得您在第一种情况下列出的行为，您需要在DerivedC类中不实现MyName（）函数）

因此，使用包装类可能是测试设置的解决方案。这是我刚刚入侵的东西，没有太多的考虑和复杂性：

#include <iostream>

class Base {
};

class DerivedA : public Base {
};

class DerivedB : public Base {
};

class DerivedC : public Base {
};

class Test {
public:
    void world( DerivedA *instance )
    {
        std::cout << "DerivedA" << std::endl;
    }

    void world( DerivedB *instance )
    {
        std::cout << "DerivedB" << std::endl;
    }

    void world( Base *instance )
    {
        std::cout << "Base" << std::endl;
    }
};

template<typename T>
class Wrapper
{
public:
    Wrapper(T* i) : instance(i)
    {
    }
    ~Wrapper()
    {
        delete instance;
    }

    void doTest(Test& t)
    {
        t.world(instance);
    }

    T* instance;
};


int main()
{
    Test hello;
    Wrapper<Base> a(new Base);
    Wrapper<DerivedA> b(new DerivedA);
    Wrapper<DerivedB> c(new DerivedB);
    Wrapper<DerivedC> d(new DerivedC);

    a.doTest(hello);
    b.doTest(hello);
    c.doTest(hello);
    d.doTest(hello);

    return 0;
}

Answer 2

在您的示例中，您没有运行时多态方案（即动态绑定）。你所拥有的是一个重载的成员函数，在重载决策中，编译器正确选择void world( Base *instance )。

为了得到你想要的东西，你应该应用如下的继承方案：

class Base {
public:
  virtual ~Base() {}
  virtual void world() const { std::cout << "Base" << std::endl; }
};

class DerivedA : public Base {
public:
  virtual ~DerivedA() {}
  void world() const { std::cout << "DerivedA" << std::endl; }
};

class DerivedB : public Base {
public:
  virtual ~DerivedB() {}
  void world() const  { std::cout << "DerivedB" << std::endl; }
};

class DerivedC : public Base {
public:
  virtual ~DerivedC() {}
  using Base::world;
};

Live Demo

修改

为了将您的代码保存在一个地方，您可以在上面的方案中添加Test类的以下更改版本：

class Test { public: void world( DerivedA *instance ) { instance->world(); } void world( DerivedB *instance ) { instance->world(); } void world( Base *instance ) { instance->world(); } };

Live Demo

不幸的是，重载解析在编译时发生，而动态调度在运行时发生。因此，如果您希望编译器从Base指针推导出基础类型，然后从Test类中选择正确的成员函数，则这是不可行的。

C ++方法参数中的动态绑定

2 个答案: