3、C++核心语法回顾：类与继承、虚函数与多态、智能指针、STL容器在解释器模式中的应用

解释器模式（Interpreter Pattern）的核心在于为语言文法定义抽象语法树（AST），并通过递归求值的方式解释执行。在C++中落地这一模式，离不开对类与继承、虚函数与多态、智能指针以及STL容器的熟练运用。本章并非泛泛的语法复习，而是紧扣解释器模式的工程实现，逐一剖析这些C++核心特性如何在AST节点设计、递归求值、内存管理与遍历操作中发挥关键作用。我们将从抽象基类的设计出发，逐步深入到多态分派、资源安全与容器选型，最终构建一个可运行的表达式解释器骨架。

上图清晰地展示了C++四大核心语法在解释器模式中的定位。类与继承构建了AST节点的类型体系，虚函数与多态实现了对同一接口的不同求值行为，智能指针解决了AST树形结构的生命周期管理难题，而STL容器则为子节点存储、变量环境管理和遍历算法提供了基础工具。下面我们逐一深入。

3.1 类与继承：构建AST节点的类型骨架

核心原理

解释器模式要求将文法中的每一条规则映射为一个类。对于表达式语言，通常存在一个抽象基类 Expression，它声明了纯虚函数 interpret()。终结符表达式（如数字、变量）和非终结符表达式（如加法、乘法）分别继承该基类。继承体系的设计直接决定了AST的扩展性——新增一种运算只需增加一个派生类，无需修改现有代码，符合开闭原则。

判断方法或操作流程

设计类层次时，遵循以下步骤：

1. 识别文法中的终结符与非终结符。终结符是文法中不可再分的最小单元，非终结符由其他表达式组合而成。
2. 定义抽象基类，将公共接口（如 interpret()）声明为纯虚函数。
3. 为每种终结符创建派生类，实现具体的求值逻辑。
4. 为每种非终结符创建派生类，其内部持有子表达式的智能指针，并在 interpret() 中递归调用子表达式。

案例拆解：数字与加法表达式

假设我们要解释简单的算术表达式，如 3 + 5。定义如下类：

class Expression {
public:
    virtual ~Expression() = default;
    virtual int interpret() const = 0;
};

class NumberExpression : public Expression {
    int value_;
public:
    explicit NumberExpression(int v) : value_(v) {}
    int interpret() const override { return value_; }
};

class AddExpression : public Expression {
    std::unique_ptr<Expression> left_;
    std::unique_ptr<Expression> right_;
public:
    AddExpression(std::unique_ptr<Expression> l, std::unique_ptr<Expression> r)
        : left_(std::move(l)), right_(std::move(r)) {}
    int interpret() const override {
        return left_->interpret() + right_->interpret();
    }
};

这里 AddExpression 通过组合两个子表达式节点，实现了递归求值。继承体系让客户端代码可以统一通过 Expression* 或引用操作所有节点，无需关心具体类型。

常见误区或总结复盘

正确的做法是：每个节点都继承自 Expression，即使是最简单的数字节点。这样，所有节点都具备统一的接口，组合和递归才能顺畅进行。

3.2 虚函数与多态：实现递归求值的动态分派

核心原理

虚函数是C++实现运行时多态的核心机制。在解释器模式中，interpret() 被声明为虚函数，当通过基类指针或引用调用时，实际执行的是派生类的版本。这种动态绑定使得AST的求值过程变成一次深度优先遍历：每个节点调用自己的 interpret()，内部再调用子节点的 interpret()，形成自然的递归。

判断方法或操作流程

判断是否需要使用虚函数，看两点：

• 是否存在一组类型，它们有共同的行为但实现不同？
• 是否需要在运行时根据对象的实际类型决定调用哪个实现？

在解释器模式中，这两个条件都满足，因此虚函数是必然选择。操作流程上，只需在基类声明纯虚函数，在派生类中重写即可。注意使用 override 关键字，让编译器帮助检查重写是否正确。

案例拆解：多态分派带来的扩展性

假设我们要增加减法运算。只需新增一个类：

class SubtractExpression : public Expression {
    std::unique_ptr<Expression> left_;
    std::unique_ptr<Expression> right_;
public:
    SubtractExpression(std::unique_ptr<Expression> l, std::unique_ptr<Expression> r)
        : left_(std::move(l)), right_(std::move(r)) {}
    int interpret() const override {
        return left_->interpret() - right_->interpret();
    }
};

客户端代码完全不需要修改，因为 interpret() 的调用方式不变。这就是多态带来的开闭原则——对扩展开放，对修改关闭。

常见误区或总结复盘

另外，避免在构造函数或析构函数中调用虚函数，因为此时动态类型尚未完全建立或已经失效，调用的是当前类的版本而非派生类的版本。

3.3 智能指针：安全管理AST节点的生命周期

核心原理

AST是一棵树形结构，节点之间存在父子关系。使用裸指针管理节点时，手动释放内存极易出错——忘记释放导致泄漏，重复释放导致崩溃。C++11引入的智能指针提供了自动内存管理：std::unique_ptr 表示独占所有权，适合表示父子关系（父节点独占子节点）；std::shared_ptr 表示共享所有权，适合多个对象共同持有同一节点（如变量引用）。

判断方法或操作流程

选择智能指针类型的依据：

场景	推荐类型	理由
AST节点组合（父子关系）	unique_ptr	每个子节点只有一个父节点，独占所有权清晰，开销低
变量环境共享（多个表达式引用同一变量）	shared_ptr	需要共享底层数据，引用计数管理生命周期
临时遍历、不拥有所有权	裸指针或引用	仅观察，不管理生命周期，避免智能指针拷贝开销

操作流程上，创建子节点时使用 std::make_unique 或 std::make_shared，避免显式 new。传递所有权时使用 std::move。

案例拆解：构建AST并安全释放

auto buildAST() {
    auto num3 = std::make_unique<NumberExpression>(3);
    auto num5 = std::make_unique<NumberExpression>(5);
    auto add = std::make_unique<AddExpression>(std::move(num3), std::move(num5));
    return add; // 返回 unique_ptr，所有权转移
}

int main() {
    auto ast = buildAST();
    int result = ast->interpret(); // 8
    // 无需手动 delete，ast 析构时自动释放整棵树
}

当 ast 离开作用域时，AddExpression 的析构函数会释放其持有的 left_ 和 right_，进而递归释放所有子节点。整个过程自动且安全。

常见误区或总结复盘

在解释器模式中，通常只需要父指向子的单向关系，因此 unique_ptr 是首选。只有在变量环境等需要共享的场景才使用 shared_ptr。

3.4 STL容器：高效组织子节点与环境数据

核心原理

STL容器为解释器模式提供了数据组织的灵活性。std::vector 适合存储子节点序列（如函数调用的参数列表）；std::unordered_map 适合实现变量名到值的映射环境；std::stack 可用于非递归的树遍历算法。选择合适的容器能显著提升代码的可读性和运行效率。

判断方法或操作流程

容器选型决策表：

需求	推荐容器	说明
有序存储子节点，支持随机访问	vector	参数列表、表达式序列
按键查找变量值，无需有序	unordered_map	哈希表，平均O(1)查找
需要有序遍历变量	map	红黑树，O(log n)操作
后进先出遍历	stack	非递归深度优先遍历

操作流程上，优先使用 emplace_back 代替 push_back 以避免临时对象拷贝；使用 find 而不是 operator[] 来检查键是否存在，避免意外插入默认值。

案例拆解：带变量的表达式解释器

class VariableExpression : public Expression {
    std::string name_;
public:
    explicit VariableExpression(std::string n) : name_(std::move(n)) {}
    int interpret(const std::unordered_map<std::string, int>& env) const {
        auto it = env.find(name_);
        if (it == env.end()) throw std::runtime_error("undefined variable: " + name_);
        return it->second;
    }
};

// 使用示例
std::unordered_map<std::string, int> env = {{"x", 10}, {"y", 20}};
auto x = std::make_unique<VariableExpression>("x");
auto y = std::make_unique<VariableExpression>("y");
auto add = std::make_unique<AddExpression>(std::move(x), std::move(y));
int result = add->interpret(env); // 30

这里 unordered_map 提供了变量名到值的快速映射，find 方法安全地检查变量是否存在，避免未定义行为。

常见误区或总结复盘

另外，注意 unordered_map 的迭代器在插入后可能失效，但 find 操作本身是安全的。在遍历过程中修改容器时，要格外小心迭代器失效问题。

3.5 综合实战：完整表达式解释器

我们将上述知识整合，实现一个支持加减乘除和括号的表达式解释器。文法如下：

expr   ::= term (('+' | '-') term)*
term   ::= factor (('*' | '/') factor)*
factor ::= NUMBER | '(' expr ')'

类设计如下：

• Expression：抽象基类，声明 interpret()。
• NumberExpression：终结符，返回数值。
• AddExpression / SubtractExpression / MultiplyExpression / DivideExpression：二元运算非终结符。

解析器使用递归下降法，构建AST：

std::unique_ptr<Expression> parseExpression() {
    auto left = parseTerm();
    while (currentToken() == '+' || currentToken() == '-') {
        char op = currentToken();
        advance();
        auto right = parseTerm();
        if (op == '+') left = std::make_unique<AddExpression>(std::move(left), std::move(right));
        else left = std::make_unique<SubtractExpression>(std::move(left), std::move(right));
    }
    return left;
}

求值时，调用根节点的 interpret()，递归计算整个表达式。整个过程体现了类与继承的层次设计、虚函数的多态分派、智能指针的安全管理以及STL容器（此处为解析器内部的流）的辅助作用。

在实际项目中，解释器模式常与访问者模式结合，将语法分析与求值分离。但无论架构如何演进，本章所述的C++核心语法都是不可或缺的基石。掌握这些特性的正确用法，是编写高质量解释器代码的前提。