使用枚举和 switch 代替访问者模式

Question

我有一个表示数学表达式的树，我想为了计算表达式树的值，我会实现访问者模式，但是在 C++ 中这涉及到很多重复，因为方法接受访问者必须在每个子类上，因为即使方法相同，类型也不相同。

class Node {
  virtual void Acccept(Visitor *visitor) = 0;
};
class ConstantNode : Node {
  virtual void Accept(Visitor *visitor) {
    visitor->visit( this );
  }
};

class VariableNode : Node {
  virtual void Accept( Visitor *visitor) {
    visitor->visit( this );
  }
};

class Visitor {
  virtual void visit(ConstantNode *node) = 0;
  virtual void visit(VariableNode *node) = 0;
};
class CalculateVisitor : Visitor {
  virtual void visit(ConstantNode *node) { /* code */ }
  virtual void visit(VariableNode *node) { /* code */ }
};

这也有一个问题，因为方法是虚拟的，所以不能有模板节点。

拥有枚举似乎要容易得多，每个节点都有一个案例，您只需在方法中而不是访问者模式中打开枚举。

class Node {
  enum NodeType {
    Constant,
    Variable
  }
  Node(NodeType type) : m_nodeType(type) {}
  NodeType m_nodeType;
};

class ConstantNode {
  ConstantNode() : Node(Constant) {}
};
class VariableNode {
  VariableNode() : Node(Variable) {}
};

int calculate(Node* node) {
  switch (node->m_nodeType) {
    case Constant:
      //...
    case Variable:
      //...
  }
}

我知道枚举版本需要动态转换，但总体而言，这似乎更可取的是必须重复大量相同的代码，这意味着它将允许模板节点，例如 (BinOpNode<std::plus>)。

或者有什么方法可以改进 C++ 中的访问者模式，使其不需要所有这些重复？

（直接在stackoverflow中输入代码，如有错误请见谅，但这是基于真实代码）

编辑：对于 BinOpNode：

template<class T>
class BinOpNode {
  T m_op = T();
  BinOpNode() : Node(BinOp) {}
};

//in calculate:
case BinOpNode:
  BinOpNode* n = dynamic_cast<BinOpNode*>(node);
  return n->m_op(calculate(n->m_left), calculate(n->m_right));

Answer 1

您可以使用模板删除重复：

// Classes implementing the mechanism

class Node {
  virtual void Accept(Visitor *visitor) = 0;
};

template<typename NodeType> class ConcreteNode
{
  virtual void Accept(Visitor* visitor)
  {
    visits<NodeType>* v = visitor;
    v->visit((NodeType*)this);
  }
};

template<typename NodeType> class visits
{
  virtual void visit(NodeType* node) = 0;
};

// The actual visitors/visited classes

class Visitor:
  visits<ConstantNode>,
  visits<VariableNode>
{
};

class ConstantNode : ConcreteNode<ConstantNote> {};
class VariableNode : ConcreteNode<VariableNode> {};

class CalculateVisitor : Visitor {
  virtual void visit(ConstantNode *node) { /* code */ }
  virtual void visit(VariableNode *node) { /* code */ }
};

请注意，您的模板节点代码将不工作，因为以下行不能工作：

BinOpNode* n = dynamic_cast<BinOpNode*>(node);

BinOpNode你定义为一个模板，你不能有一个指向模板的指针，只有一个指向类的指针。例如，您可能有一个指向从BinOpNode 生成的特定 类的指针，例如

BinOpNode<int>* n = dynamic_cast<BinOpNode<int>*>(node);

但这也可以由访问者模式完美处理；使用上面的模板代码：

class Visitor:
  public visits<BinOpNode<int> >,
  public visits<BinOpNode<double> >,
  ...
{
};

template<typename T> class BinOpNode:
  public ConcreteNode<BinOpNode<T> >
{
  ...
};