请注意:这些是描述一般困境的代码片段。完整的代码确实包括“include guards”/#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，以便 accept 方法知道 Visitor 对象有一个 visit 方法。也就是说，Visitor 和 visit() 都声明为 virtual void accept(Visitor* v) {v->visit(this);}。但与此同时，ASTVisitor.h 需要 AST.h，以便 Visitor 类知道 Node 的所有具体子类都存在。也就是说，例如，为 virtual void visit(StringElement* e)

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

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

最佳答案

是的，在 C++ 中有一种方法可以做到这一点。您需要使用前向声明，并在需要时拆分声明和定义。这是一个示例(请阅读评论以获取解释):

#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否则您最终可能会多次包含同一个文件，这会导致很多错误。

关于c++ - 如何通过 AST 为访问者模式解决 C++ 中的 header 重复问题，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12965819/