如何解决 C++ 中针对 AST 上的访问者模式的标头重复问题

Question

请注意：这些是描述一般困境的代码 sn-ps。完整的代码确实包括“包含警卫”/#pragma once/whathaveyou。

我正在实现用于遍历 AST 的访问者模式，并想知道 C++ 解决以下问题的方法是什么：

我有 AST.h，它有基本的 AST 节点类声明：

    class Node
    {
    public:
        virtual void accept(Visitor* v) {v->visit(this);}
    };

以及用于声明、表达式等的所有具体节点子类。

然后我有声明访问者界面的 ASTVisitor.h，大致如下：

    class Visitor
    {
    public:
        Visitor() {}
        virtual ~Visitor() {}

        virtual void visit(StringElement* e) {}
        virtual void visit(RealElement* e) {}
        virtual void visit(IntegerElement* e) {}
        ...

问题是，AST.h 需要 ASTVisitor.h 以便接受方法知道访问者对象有访问方法。也就是说，Visitor 和 visit() 都被声明为 virtual void accept(Visitor* v) {v->visit(this);}。但与此同时，ASTVisitor.h 需要 AST.h 以便 Visitor 类知道 Node 的所有具体子类都存在。也就是说，例如，在 virtual void visit(StringElement* e) 中为签名声明 StringElement

但是在 ASTVisitor.h 中包含 ASTVisitor.h 和在 ASTVisitor.h 中包含 AST.h 会导致访问者类没有被 Node 类“看到”，因此，它作为接受参数的类型无效。此外，像 AST.h 中的 class Visitor; 这样的前向声明只能解决方法签名的类型问题，但在方法 v->visit(this) 内部仍然无效，因为前向声明没有说明访问者类的方法。

那么解决这个问题的 C++ 方法是什么？

Answer 1

是的，在 C++ 中有一种方法可以做到这一点。您需要使用前向声明，如果需要，还需要拆分声明和定义。这是一个示例（请阅读 cmets 进行解释）：

#include <cstdio>
#include <string>

/// --- A.hpp ---

// First, you have to forward declare a visitor type.
class Visitor;

// Then declare/define a node base class (interface).
class Node {
  public:
    Node() {}
    virtual ~Node() {}

    // Note that Visitor, as a type, is referenced here, but none of its
    // "body" is used, so forward declaration is enough for us.
    virtual void accept(Visitor & v) = 0;
};

/// --- B.hpp (includes A.hpp) ---

// Then, to declare the actual interface for a visitor, we must play the same
// trick with forward declaration, but for specific node types:
class NodeA;
class NodeB;

// And once those types are "pre-declared", declare visitor interface.
class Visitor {
  public:
    Visitor() {}
    virtual ~Visitor() {}

    virtual void visit(const Node & node);
    virtual void visit(const NodeA & node);
    virtual void visit(const NodeB & node);
};

/// --- C.hpp (includes B.hpp) ---

// Once visitor is declared, declare/define specific nodes.
class NodeA : public Node {
  public:
    std::string node_name;

    NodeA() : node_name("I am a node of type A!") {}
    virtual ~NodeA() {}
    virtual void accept(Visitor & v) { v.visit(*this); }
};

class NodeB : public Node {
  public:
    std::string node_name;

    NodeB() : node_name("B node here!") {}
    virtual ~NodeB() {}
    virtual void accept(Visitor & v) { v.visit(*this); }
};

// --- B.cpp (includes B.hpp and C.hpp) ---

// Now, nodes are declared, so that we can define visitor's methods.
// Note that if you don't need to use "node" parameters, this can
// as well go with declaration and there is no need to "define" this later.
void Visitor::visit(const Node & node) {
    printf("Base visitor got base node\n");
}

void Visitor::visit(const NodeA & node) {
    printf("Base visitor got node A\n");
}

void Visitor::visit(const NodeB & node) {
    printf("Base visitor got node B\n");
}

// --- YourProgram.[cpp|hpp] includes at most C.hpp --

// Than, at any point in your program, you can have a specific visitor:
class MyVisitor : public Visitor {
  public:
    MyVisitor() {}
    virtual ~MyVisitor() {}

    virtual void visit(const Node & node) {
        printf("Got base node...\n");
    }

    virtual void visit(const NodeA & node) {
        printf("Got %s\n", node.node_name.c_str());
    }

    virtual void visit(const NodeB & node) {
        printf("Got %s\n", node.node_name.c_str());
    }
};

// And everything can be used like this, for example:
int main()
{
    Visitor generic_visitor;
    MyVisitor my_visitor;

    NodeA().accept(generic_visitor);
    NodeA().accept(my_visitor);
    NodeB().accept(generic_visitor);
    NodeB().accept(my_visitor);
}

...顺便说一句，不要忘记使用include guards，否则您可能会多次包含同一个文件，这会导致很多错误。

Answer 2

需要明确的是，这不是关于访问者模式的问题。更多的是关于递归包含问题...

首先，您应该确保在您的项目中使用单独的编译。也就是说，将接口放在 .h 文件中，将实现放在 .cpp 文件中。从您的问题来看，是否是这种情况并不是很清楚，但是您对 Node::accept() 的实现不应该在 IMO 标头中。

转发声明

使用单独编译时，您可以利用前向声明。头文件中引用的类型不需要编译器知道这些类型的接口，可以简单地在头文件的顶部声明。因此，例如，在 AST.h 中您不需要包含 ASTVisitor.h，只需执行以下操作（再次假设您已将 accept() 的实现移动到 cpp (AST.cpp) 文件中。

class Visitor;
class Node
{
public:
    virtual void accept(Visitor* v);
};

请注意，这是可行的，因为编译器不需要了解有关 Visitor 类的任何信息。它仅作为指针 (Visitor*) 引用，因此编译器不需要知道接口或实现（内存占用）。

预处理器。

如果您打算将 accept() 的实现留在头文件中，您可以使用预处理器方法。无论如何，我总是推荐这是一个好的做法。将所有头文件包装在 #ifndef 块中。例如，在 AST.h 中（我仍然有前向声明）：

#ifndef ast_h
#define ast_h

class Visitor;

class Node
{
    ...
}

#endif //ast_h

然后在 ASTVisitor.h 中

#ifndef astvisitor_h
#define astvisitor_h

class StringElement;
class RealElement;
class IntegerElement;

class Visitor
{
    ...
}

#endif //astvisitor_h

这将阻止编译器尝试在单个编译单元中多次包含并重新定义该类。

从您上面的代码看起来，如果您不想使用预处理器，您可能可以只使用单独的编译和前向声明来获得优势。告诉我进展如何。

Answer 3

创建、编译和链接一个包含accept()实现的文件AST.cpp：

void Node::accept(Visitor* v) {v->visit(this);}

现在，ASTVisitor.h 包含 AST.h，而 AST.h 声明 class Visitor;。 CPP 文件包含这两个头文件。

为什么accept 声明为virtual？

对于“真实”接口，在Visitor 的方法声明中将{} 替换为= 0;。

编辑：考虑您的实施，并在 Vlad 的回答的帮助下，我现在知道出了什么问题。使用“奇怪重复的模板”模式避免重复执行accept：

class Node {
    void accept(Visitor* v) = 0;
}

template <class ME>
class NodeAcceptor : public Node {
    void accept(Visitor* v);
}

template <class ME>
void NodeAcceptor<ME>::accept(Visitor* v) { v->accept(static_cast<ME*>(this)); }

从NodeAcceptor<NodeSubclass> 派生每个NodeSubclass。

这确保调用了正确的accept() 方法。