C++ 导致解析错误的复制构造函数错误是什么？

我正在为一种小型语言编写一个编译器，我的解析器类目前负责构建一个AST供以后使用。但是，递归表达式无法正常工作，因为包含子节点的每个AST节点中的向量无法正常工作。当前我的AST的头文件如下所示：

class AST
{
public:
    enum ASTtype {nil, fdecl, pdecl, vdecl, rd, wr, set, rdLV, setLV, exprLV, add, sub, mul, fcall,
        divide, mod, lt, gt, lte, gte, eq, ne, aAnd, aOr, aNot, aNeg, nConst, t, f, vs, dl, loop,
        cond, ss};
    enum scalarType {tNA, tINVALID, tINT, tLONG, tBOOL};
    AST ();
    AST (AST const&);
    AST (ASTtype);
    AST (ASTtype, std::string);
    void addChild(AST);
    ASTtype getNodeType();
    std::string text;
    ASTtype nodeType;
    int size;
    scalarType evalType;
    std::vector<AST> children;
};

一个不起作用的示例表达式是+1+2+3 4。 它应该解析成这样的AST:+[1，+[2，+[3,4]]， 但我得到的却是：+[1，+[]

---

关于我做错了什么有什么建议吗？

parent.children.push\u backexpr复制了这个表达式。因此，它调用AST:：ASTAST const&。其中的一个错误肯定会导致您看到的问题。但是，如果没有代码，我们无法在其中找到错误。

您能给出关于这个复制构造函数错误的更多细节吗？您是说如果您有一个AST如果你的复制构造函数有bug，我会说复制构造函数是一个错误吗？我真的不知道是什么引起了这个问题，我想如果有人看了E，它可能会发现C++的一个错误或基本误解。我忽略了。

void Parser::e(AST& parent)
{
    AST expr;
    AST::ASTtype check = AST::nil;
    bool binOp = false;

    switch (lookahead.type)
    {
        case Lexer::AND    : check = AST::aAnd  ; binOp = true; break; 
        case Lexer::OR     : check = AST::aOr   ; binOp = true; break; 
        case Lexer::NOT    : check = AST::aNot  ; break;
        case Lexer::NEG    : check = AST::aNeg  ; break;
        case Lexer::PLUS   : check = AST::add   ; binOp = true; break;
        case Lexer::MINUS  : check = AST::sub   ; binOp = true; break;
        case Lexer::SPLAT  : check = AST::mul   ; binOp = true; break;
        case Lexer::FSLASH : check = AST::divide; binOp = true; break;
        case Lexer::MOD    : check = AST::mod   ; binOp = true; break;
        case Lexer::EQ     : check = AST::eq    ; binOp = true; break;
        case Lexer::LT     : check = AST::lt    ; binOp = true; break;
        case Lexer::GT     : check = AST::gt    ; binOp = true; break;
        case Lexer::GTE    : check = AST::gte   ; binOp = true; break;
        case Lexer::LTE    : check = AST::lte   ; binOp = true; break;
        case Lexer::NE     : check = AST::ne    ; binOp = true; break;
    }
    if (check != AST::nil && binOp)
    {
        match(lookahead.type);
        expr = AST(check);
        e(expr);
        e(expr);
    } else if (check != AST::nil && !binOp) {
        match(lookahead.type);
        expr = AST(check);
    } else if (lookahead.type == Lexer::IDENT) {

        if (symbols.resolve(lookahead.text).sym_type == symbol::FUNC)
        {
            expr = AST(AST::fcall, lookahead.text);
            match(Lexer::IDENT);
            while (lookahead.type != Lexer::BANG)
            {
                e(expr);
            }
            match(Lexer::BANG);
        } else {
            expr = AST(AST::exprLV);
            lv(expr);
        }
    } else if (lookahead.type == Lexer::T) {
        match(Lexer::T); //true
        expr = AST(AST::t);
    } else if (lookahead.type == Lexer::F) {
        match(Lexer::F); //false
        expr = AST(AST::f);
    } else {
        expr = AST(AST::nConst, lookahead.text);
        match(Lexer::NUM);
    }
    parent.children.push_back(expr);
}