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

我正在重新编写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继承的所有类型，但仍然能够对其进行两次分派(dispatch)。如果我们不得不多次重复这样的列表，那将特别糟糕。我基本上不希望节点知道访问者(也许当有为该节点定制的访问者时除外)或其他节点类。我也不想让访问者知道节点(除了定制访问者的节点类型以外)。而且，我不需要这些信息的任何中央存储库，因为它将是始终触发重新编译世界的头文件。

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

最佳答案

在visitor中执行的双重调度是一个将一对(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 中进行搜索。