Question

我正在为我的语言编写一个基本词法分析器，我想遍历Node对象中的AST个对象树。 AST中的每个Node对象都有Children类型的成员vector<Node>。这是为了允许节点具有子节点（例如，表达式节点coul存储两个节点operand_a和operand_b）。

问题是，我不知道如何使for循环遍历节点的AST，其子节点可以拥有无限数量的自己的子节点，等等。

这是我的AST / Node类的标题。

enum NodeType {
    ... 
TOKEN_SIGN_PLUS,
TOKEN_SIGN_MINUS,
    ...
};

class Node;
struct AST
{
    vector<Node> Nodes;
    void addNode(Node node);
    void deleteNode(size_t nodeID);
    //void deleteNodeRange(size_t from, size_t to);
    void popEndNode();
    size_t NodeCount() { return Nodes.size(); }
    AST() {}
    ~AST() {}
};

struct Node  
{
    friend AST;
    AST* ParentAST;
    NodeType NodeType;
    size_t NodeID();
    string Data;
    vector<Node> Children;
    size_t ChildCount() { return Children.size(); }
    Node() {}
    ~Node() {}
  private:
    size_t _nodeID;
};

所以我的问题是，我怎样才能在每个父节点上遍历每个子节点及其子节点，所以我可以打印这样的东西：

NODE: "EXPR"
            NODE: "INT_LITERAL"
            NODE: "OP_PLUS"
            NODE: "INT_LITERAL"

OR，更重要的是（多个嵌套子代）：

NODE: "DECL_AND_INIT_VARIABLE"
                              NODE: "KEYWORD_INT"
                              NODE: "IDENTIFIER"
                              NODE: "OP_EQ"
                              NODE: "EXPR"
                                          NODE: "INT_LITERAL"
                                          NODE: "OP_PLUS"
                                          NODE: "INT_LITERAL"

Answer 1

这是一个快速/粗略的例子，但可能含糊不清：

struct AST
{
   ...
   void print() const;
};
...
struct Node
{
   ...
   void print(int indent) const;
};

void AST::print() const
{
    for(const auto& node:Nodes)
        node.print(0);
}

void Node::print(int indent) const
{
    auto thisindent = strlen("NODE: ") + Data.length();
    cout << string(indent + thisindent, ' ');
    cout << "NODE: " << Data << endl;
    if(Children.size() > 0)
        for(const auto& child:Children)
            child.print(indent + thisindent);
}

在AST中解析节点及其自身（无限量嵌套）子节点

1 个答案: