我可以将CRTP与虚拟函数或函子一起用于允许对类进行更改的访问者算法

Question

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

首先，我们有一个AST层次结构，它基于Node抽象基类和与其关联的访问者模式。接下来，我们有一个单独的语义层次结构，该层次结构使用了各种类（我可能可以全部重新设置基础，以便Node也是所有这些类的最低级别的类）。随着我们认识到更多的专业化，语义层次结构可能会增长。这些类有一个单独的Visitor模式。创建了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继承的所有类型，但仍然可以对它们进行两次分派。如果我们不得不多次重复这样的列表，那将特别糟糕。我基本上不希望节点知道访问者（除非有为该节点定制的访问者）或其他节点类。我也不想让访问者知道节点（除了定制访问者的节点类型以外）。而且，我不需要任何此类信息的中央存储库，因为它将成为始终触发重新编译世界的标头。

我应该尝试任何有关代码实验的想法？我们可能会使用G ++或CLang进行编译。

Answer 1

在访问者中执行的双重调度是一个将一对 (visitor_dynamic_type,acceptor_dynamic_type) 与一个函数（C++ 函数）相关联的函数（在函数的数学意义上）。

由于您不希望基本访问者知道从基本接受器派生的所有类型，因此必须通过抽象类型的方式来标识acceptor_dynamic_type。所以我们可以用type_index它。（您可能会找到更好的方法来提供对某些类型的地图更友好的 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
   };

具体来说不再是访客模式。这只是一种原始的暴力去虚拟化，代价是在地图中进行搜索。