c++ - 重载方法以实现接口(interface)的特殊情况

Question

免责声明:我无法清楚地描述我正在尝试做什么，所以我希望这个例子比我的解释更清楚!请建议任何重新措辞以使其更清楚。 :)

---

是否可以使用比接口(interface)所需的版本更具体的版本来覆盖函数，以便与一般情况分开处理该接口(interface)中方法参数的子类？ (下面的例子和更好的解释......)如果不能直接完成，是否有一些模式可以用来达到类似的效果？

例子

#include <iostream>

class BaseNode {};
class DerivedNode : public BaseNode {};

class NodeProcessingInterface
{
public:
    virtual void processNode(BaseNode* node) = 0;
};

class MyNodeProcessor : public NodeProcessingInterface
{
public:
    virtual void processNode(BaseNode* node)
    {
        std::cout << "Processing a node." << std::endl;
    }

    virtual void processNode(DerivedNode* node)
    {
        std::cout << "Special processing for a DerivedNode." << std::endl;
    }
};

int main()
{
    BaseNode* bn = new BaseNode();
    DerivedNode* dn = new DerivedNode();

    NodeProcessingInterface* processor = new MyNodeProcessor();
    // Calls MyNodeProcessor::processNode(BaseNode) as expected.
    processor->processNode(bn);
    // Calls MyNodeProcessor::processNode(BaseNode).
    // I would like this to call MyNodeProcessor::processNode(DerivedNode).
    processor->processNode(dn);

    delete bn;
    delete dn;
    delete processor;

    return 0;
}

我的动力

我希望能够实现几个不同的具体 NodeProcessor，其中一些将对所有节点一视同仁(即仅实现界面中显示的内容)，而另一些将区分不同的节点节点类型(如 MyNodeProcessor)。所以我想第二次调用 processNode(dn) 通过重载(某些部分/子类)接口(interface)方法来使用 MyNodeProcessor::processNode(DerivedNode) 中的实现.这可能吗？

显然，如果我将 processor 更改为 MyNodeProcessor* 类型，那么这会按预期工作，但我需要能够互换使用不同的节点处理器。

我还可以通过使用单个方法 processNode(BaseNode) 来解决这个问题，该方法在运行时检查其参数的精确类型并基于此进行分支。在我的代码中包含此检查对我来说似乎并不优雅(尤其是随着节点类型数量的增加并且我有一个巨大的 switch 语句)。我觉得语言应该能够提供帮助。

---

我正在使用 C++，但如果您愿意(或者如果这在其他语言中更容易/不同)，我也对一般答案感兴趣。

Answer 1

不，这是不可能的。虚方法调度发生在编译时，即使用处理器指针的静态类型，即 NodeProcessingInterface。如果该基类型只有一个虚函数，则只会调用该虚函数(或其覆盖实现)。编译器无法确定是否有派生的 NodeProcessor 类实现了更多不同的功能。

因此，不是在派生类中使方法多样化，而是必须以相反的方式进行:在基类中声明您需要的所有不同虚函数，并根据需要覆盖它们:

class NodeProcessingInterface
{
public:
    virtual void processNode(BaseNode* node) = 0;

  //simplify the method definition for complex node hierarchies:
  #define PROCESS(_derived_, _base_)            \
    virtual void processNode(_derived_* node) { \
      processNode(static_cast<_base_*>(node));  \
    }    

  PROCESS(DerivedNode, BaseNode)
  PROCESS(FurtherDerivedNode, DerivedNode)
  PROCESS(AnotherDerivedNode, BaseNode)

  #undef PROCESS

};

class BoringNodeProcessor : public NodeProcessingInterface
{
public:
    virtual void processNode(BaseNode* node) override
    {
        std::cout << "It's all the same.\n";
    }
};

class InterestingNodeProcessor : public NodeProcessingInterface
{
public:
    virtual void processNode(BaseNode* node) override
    {
        std::cout << "A Base.\n";
    }

    virtual void processNode(DerivedNode* node) override
    {
        std::cout << "A Derived.\n";
    }
};