基于抽象类快速确定子类

Question

我有一个 C++ 基类 CAbstrInstruction 和大量的直接子类：

class CAbstrInstruction { /* ... */ };

class CSleepInstruction: public CAbstrInstruction { /* ... */ };
class CSetInstruction: public CAbstrInstruction { /* ... */ };
class CIfInstruction: public CAbstrInstruction { /* ... */ };
class CWhileInstruction: public CAbstrInstruction { /* ... */ };
// ...

还有一个 CScriptWorker 公开了一个公共方法 execute：

class CScriptWorker
{
    public:
        void execute (const CAbstrInstruction *pI);

    private:
        void doSleep (const CSleepInstruction *pI);
        void doSet (const CSetInstruction *pI);
        void doIf (const CIfInstruction *pI);
        void doWhile (const CWhileInstruction *pI);
        // ...
};

目前execute方法的实现是这样的：

void CScriptWorker::execute (const CAbstrInstruction *pI)
{
    const CSleepInstruction *pSleep =
        dynamic_cast<const CSleepInstruction *>(pI);

    if (pSleep != NULL)
    {
        doSleep (*pSleep);
        return;
    }

    const CSetInstruction *pSet =
        dynamic_cast<const CSetInstruction *>(pI);

    if (pSet != NULL)
    {
        doSet (*pSet);
        return;
    }

    const CIfInstruction *pIf =
        dynamic_cast<const CIfInstruction *>(pI);

    if (pIf != NULL)
    {
        doIf (*pIf);
        return;
    }

    const CWhileInstruction *pWhile =
        dynamic_cast<const CWhileInstruction *>(pI);

    if (pWhile != NULL)
    {
        doWhile (*pWhile);
        return;
    }

    /* ... */
}

这非常笨拙，需要 O(log(n)) 才能调用正确的私有方法。有没有 是否有任何设计模式或语言结构可以简化这一点？

澄清：我可以将私有执行方法 do... 移动到指令中 类。执行方法将简单地变成：

    void execute (const CAbstrInstruction *pI) { pI->execute(); }

但是，这不是我想要的。为什么不？ 关注点分离：CAbstrInstruction 的实例只是对要做什么的描述。它们构成了脚本的抽象语法树。这已经足够令人担忧了。 CScriptWorker 关心的是实际执行指令所描述的内容。 CScriptWorker 知道脚本运行的上下文。CAbstrInstruction 不应该知道。

Answer 1

如果事情很简单，将execute 方法的实现移动到CAbstrInstruction 的子类中可能是答案。但是，OP 明确指出 execute 方法应单独保存在 CScriptWorker 中，以便将了解 what 将要完成的操作（指令的工作）与 分开如何 完成（CScriptWorker 的工作）。这可以通过 double dispatch 实现，有时也称为 visitor pattern：

class IInstructionDispatchTarget
{
    public:
    virtual void onDispatch (const CSleepInstruction &instr) = 0;
    virtual void onDispatch (const CSetInstruction &instr) = 0;
};
class CAbstrInstruction
{
    public:
    virtual void dispatch (IInstructionDispatchTarget &t) const = 0;
};
class CSleepInstruction: public CAbstrInstruction
{
     public:
     virtual void dispatch (IInstructionDispatchTarget &t) const override
         { t.onDispatch (*this); }
};
class CSetInstruction: public CAbstrInstruction
{
     public:
     virtual void dispatch (IInstructionDispatchTarget &t) const override
         { t.onDispatch (*this); }
};
class CScriptWorker: public IInstructionDispatchTarget
{
    public:
    void execute (const CAbstrInstruction *pI)
        { pI->dispatch (*this); }
    virtual void onDispatch (const CSleepInstruction &instr) override
    {
        // do sleep
    }
    virtual void onDispatch (const CSetInstruction &instr) override
    {
        // do set
    }
};

当execute 被CScriptWorker 调用时，它会调用指令的dispatch 方法。作为回报，该指令调用调度目标上的onDispatch 方法，使用其特定的this 指针，从而调用正确的方法。

接口IInstructionDispatchTarget 有两个用途。一方面，它确保CAbstrInstruction 的实例根本不需要知道CScriptWorker；他们只需要知道界面。另一方面，它允许其他调度目标使用相同的机制，例如遍历指令以优化 AST 时。

如果认为IInstructionDispatchTarget 的存在是不必要的，则可以稍微简化一下，如 ROX 的回答所示。

Answer 2

CAbstrInstruction 应该定义一个纯虚方法（在您的示例中为execute()），您的子类应该覆盖并实现该方法。

举个例子：

class CAbstrInstruction 
{
     /* ... */
     virtual void execute() const = 0;
}

class CSleepInstruction 
{
     /* ... */
     void execute() override const
     {
         /* your code here */
     }
}

/* ... */
void CScriptWorker::execute (const CAbstrInstruction *pI)
{
    pI->execute();
}

Answer 3

当客户端不需要知道对象的具体类型时，最好使用继承。您想使用variant type，因为您有固定数量的已知指令，并且您的执行程序需要知道它正在执行哪种指令。如果您是 C++17 之前的版本，则使用 std::variant 或 boost::variant 最简单。

#include <variant>

struct Set {};
struct If {};
struct While {};

using Instruction = std::variant<
    Set,
    If,
    While
    >;

#include <iostream>

struct Executor {
    void operator()(Set const&) const { std::cout << "Set\n"; }
    void operator()(If const&) const { std::cout << "If\n"; }
    void operator()(While const&) const { std::cout << "While\n"; }
};

void execute(Instruction const& i) {
    std::visit(Executor(), i);
}

例子：

#include <vector>

int main() {
    for (auto const& i : std::vector<Instruction>{While(), If(), Set()}) {
        execute(i);
    }
}

输出：

While
If
Set

Answer 4

如果您有其他将实现 IInstructionVisitor 接口的类，则访问者模式可以很好地工作。这确保所有这些类都可以处理相同的指令类集。

如果您没有从 IInstructorVisitor 派生的其他类，那么您可以稍微简化一下：-

class CScriptWorker
{
    public:
        void execute (const CAbstrInstruction* pI)
        {
           pI->ResolveInstructionType(*this);
        }

    // Can be made friends of appropriate instruction classes or left public as you see fit
       void doInstruction (const CSleepInstruction* pI);
       void doInstruction (const CSetInstruction* pI);
       void doInstruction (const CIfInstruction* pI);
       void doInstruction (const CWhileInstruction* pI);
    // note the name is now the same, name of the parameter should be enough to tell what's being done
    // also I'd probably make these references not pointers

};


class CAbstrInstruction
{
    public:
    virtual void ResolveInstructionType (CScriptWorker& v) = 0;
};


class CSleepInstruction: public CAbstrInstruction
{
     public:
     void ResolveInstructionType (CScriptWorker& w) override { w.doInstruction (this); }
};

简化的一点好处是，现在代码稍微少了一点，如果添加新指令需要修改的代码稍微少一点，您可以选择除访问、访问者等以外的名称。