C++中使用抽象类Expression作为子类成员报错求助

编译错误的核心原因是抽象类无法被直接实例化。你的Expression类包含纯虚函数evaluate()，属于抽象类，C不允许创建抽象类的对象。而你在Add类中声明Expression left;，本质是尝试创建抽象类的实例，这违反了C的规则，所以编译器报错。

解决方案：使用指针/智能指针存储抽象类的子类实例 #

抽象类不能直接实例化，但可以通过指针或引用指向它的子类对象，以此实现多态。推荐使用智能指针来自动管理内存，避免手动释放带来的泄漏风险。

步骤1：完善抽象类的基础定义 #

给Expression添加虚析构函数，确保子类对象能被正确销毁；同时将核心成员设为public（方便子类继承和调用）：

#pragma once
#include <memory> // 智能指针依赖的头文件

class Expression {
public:
    virtual Expression* evaluate() = 0;
    virtual ~Expression() = default; // 虚析构函数，必须添加
};

步骤2：实现子类示例（如Number） #

class Number : public Expression {
private:
    int value;
public:
    Number(int val) : value(val) {}
    
    // 重写纯虚函数
    Expression* evaluate() override {
        // Number是叶子节点，返回自身的副本（可根据需求调整逻辑）
        return new Number(value);
    }
    
    // 提供获取数值的方法，方便Add类计算
    int getValue() const { return value; }
};

步骤3：修改Add类的实现（使用智能指针） #

用std::unique_ptr<Expression>作为成员类型，构造函数接收智能指针并转移所有权：

class Add : public Expression { // 必须用public继承，否则多态失效
private:
    std::unique_ptr<Expression> left;
    std::unique_ptr<Expression> right;
public:
    // 构造函数：通过std::move转移智能指针的所有权
    Add(std::unique_ptr<Expression> l, std::unique_ptr<Expression> r)
        : left(std::move(l)), right(std::move(r)) {}
    
    Expression* evaluate() override {
        // 递归计算左右表达式的结果
        auto leftEval = std::unique_ptr<Expression>(left->evaluate());
        auto rightEval = std::unique_ptr<Expression>(right->evaluate());
        
        // 将计算结果转型为Number（需确保表达式最终能求值为Number）
        Number* leftNum = dynamic_cast<Number*>(leftEval.get());
        Number* rightNum = dynamic_cast<Number*>(rightEval.get());
        
        if (leftNum && rightNum) {
            return new Number(leftNum->getValue() + rightNum->getValue());
        }
        
        // 处理类型不匹配的异常情况（可根据需求扩展）
        return nullptr;
    }
};

步骤4：使用示例 #

#include <iostream>

int main() {
    // 构建嵌套表达式：5 + (3 + 2)
    auto expr = std::make_unique<Add>(
        std::make_unique<Number>(5),
        std::make_unique<Add>(
            std::make_unique<Number>(3),
            std::make_unique<Number>(2)
        )
    );
    
    auto result = std::unique_ptr<Expression>(expr->evaluate());
    Number* resultNum = dynamic_cast<Number*>(result.get());
    
    if (resultNum) {
        std::cout << "计算结果：" << resultNum->getValue() << std::endl; // 输出10
    }
    
    return 0;
}

关键注意事项 #

• 虚析构函数：抽象类必须声明虚析构函数，否则当通过基类指针删除子类对象时，只会调用基类的析构函数，导致子类资源泄漏。
• public继承：子类继承抽象类时必须用public权限，否则基类的public成员会被隐藏，无法实现多态调用。
• 内存管理：如果使用原始指针，必须手动在析构函数中释放成员对象的内存；智能指针（如std::unique_ptr、std::shared_ptr）会自动处理内存释放，更安全。

内容的提问来源于stack exchange，提问作者Joshua Morris