c++ - 我可以将 CRTP 与虚函数或仿函数一起用于访问者算法以容忍类的更改吗

Question

我正在重写编译器的 IR，其中 IR 类和算法都在不断变化。当前编译器至少有 2 个当前 IR，它们用于我要合并的不同阶段。

首先，我们有一个 AST 层次结构，它基于一个 Node 抽象基类和一个与之关联的访问者模式。接下来，我们有一个单独的语义层次结构，它使用各种类(我可能可以全部 rebase ，这样 Node 也是所有类的最低级别)。随着我们认识到更多的特化，语义层次可能会增长。这些类有一个单独的访问者模式。为执行生成的程序创建了 2 个“可执行”IR。

我的目标是合并 AST 和语义层次结构，并合并它们生成的可执行形式。这将减少由于两种形式的不一致而导致的错误数量。

但是，正如我所指出的，语义层次结构很可能会添加新的类。此外，我们还可能添加新的访问者算法。

所以，我想做的是这样的事情:

class VisitorBase;
class Node;

template Visitable<T> {
   virtual preVisitAccept(VisitorBase *v) { 
      v->preVisit(static_cast<T *>this); }
   virtual inVisitAccept(VisitorBase *v) { 
      v->inVisit(static_cast<T *>this); }
   virtual postVisitAccept(VisitorBase *v) { 
      v->postVisit(static_cast<T *>this); }
   };

template Visitor<T> {
   virtual preVisit(Node *n) { /* do nothing by default */ }
   virtual inVisit(Node *n) { /* do nothing by default */ }
   virtual postVisit(Node *n) { /* do nothing by default */ }
   };

class VisitorBase : Visitor<VistorBase> {
   };

class Node : Visitable<Node> {
   // Code that walks the tree will be probably here 
   // invoking pre, in, and post visit functions as appropriate
}

class ArithOp: node {
   // I don't mind repeating this in each class
   // Some visitor may be specialized on this function
   preVisitAccept(VisitorBase *v) override { 
      v->preVisit(static_cast<arithOp *>this); }
   ...
}

class PrettyPrintVisitor : VisitorBase {
    //  Here is a specialized visitor
    preVisit(ArithOp *n) override { /* specialized code /* }
}

我不介意在每个派生节点类或每个访问者类中重复一些代码。

我想要摆脱的是从 Node 继承的所有类型的脆弱静态列表(我们必须更新)，但仍然能够对它们进行双重分派(dispatch)。如果我们不得不多次重复这样的列表，那将尤其糟糕。我基本上不希望节点知道访问者(除非有为该节点定制的访问者)或其他节点类。我也不希望访问者了解节点(访问者自定义的节点类型除外)。此外，我不想要此类信息的任何中央存储库，因为这将是一个始终触发重新编译世界的 header ....

关于我应该尝试的代码实验有什么想法吗？我们可能会使用 G++ 或 CLang 对其进行编译。

Answer 1

访问者中执行的双重分派(dispatch)是一个函数(在函数的数学意义上)，它将一对 (visitor_dynamic_type,acceptor_dynamic_type) 关联到一个函数(C++ 函数)。

由于您不希望基访问者知道从基接受器派生的所有类型，acceptor_dynamic_type 必须通过抽象类型的方式来标识。所以我们可以为此使用type_index。 (您可能会找到更好的方法来提供对某种 map 更友好的 id)

所以你可以这样实现访问者(几乎是伪代码):

template<class T>
struct Visitor {
   map<type_index,void(T&,Node&)>* vfuncs //equivalent a vtbl_ptr
   void Visit(Node& n){
      //manual devirtualization step1: look if a function exist
      //                               for the dynamic type of the acceptor
      if (auto it=vfuncs.find(typeid(n));it!=vfuncs.end()){
          (*it)(statis_cast<T&>(*this),n);
          }
      else{ //do default stuff}
      };
   };
//only visit concrete_Node
struct concrete_visitor:visitor_base{
   static void visit(visitor_base& v,Node& n){
       //manual devirtualization step2: cast references
       auto& cn = static_cast<concrete_Node&>(n);
       auto& self = static_cast<concrete_visitor&>(v);
       //...
       }
   static inline map<type_index,void(visitor_base&,Node&)> vfuncs
                                             {typeid(concrete_Node),&visit};
   concrete_visitor():visitor_base{&vfuncs}{} //vtbl_ptr initialization
   };

具体不再是访问者模式。这只是以在 map 中搜索为代价的原始蛮力去虚拟化。