已掌握普通派生类指针存基类vector方法，抽象派生类该如何存储？

嘿，你这里的核心卡点其实是抽象类不能直接实例化——毕竟你没法new一个本身还带着纯虚函数的抽象派生类对吧？咱们一步步来解决这个问题：

首先先修正你代码里的一个小错误：构造函数不能被声明为virtual，这是C++语法不允许的。另外，抽象基类必须包含至少一个纯虚函数（比如virtual void func() = 0;），不然它就不是真正的抽象类。

步骤1：完善抽象类层级 #

先把你的抽象类结构补全，确保每个抽象类都有纯虚函数：

#include <vector>
#include <iostream>

// 顶层抽象基类
class interface {
public:
    // 构造函数不能加virtual！
    interface() = default;
    // 析构函数必须是virtual，保证多态析构，避免内存泄漏
    virtual ~interface() = default;
    // 纯虚函数，标记这是抽象类
    virtual void core_operation() = 0;
};

// 第一层抽象派生类1
class abstract_derived_1 : virtual public interface {
public:
    abstract_derived_1() = default;
    virtual ~abstract_derived_1() = default;
    // 新增纯虚函数，延续抽象特性
    virtual void specific_op_1() = 0;
};

// 第一层抽象派生类2
class abstract_derived_2 : virtual public interface {
public:
    abstract_derived_2() = default;
    virtual ~abstract_derived_2() = default;
    virtual void specific_op_2() = 0;
};

步骤2：创建具体的派生类 #

因为抽象类不能实例化，我们需要创建实现了所有纯虚函数的具体类，这些类才是可以被new出来的：

// 实现abstract_derived_1的具体类
class ConcreteImpl1 : public abstract_derived_1 {
public:
    void core_operation() override {
        std::cout << "ConcreteImpl1执行核心操作\n";
    }

    void specific_op_1() override {
        std::cout << "ConcreteImpl1执行专属操作1\n";
    }
};

// 实现abstract_derived_2的具体类
class ConcreteImpl2 : public abstract_derived_2 {
public:
    void core_operation() override {
        std::cout << "ConcreteImpl2执行核心操作\n";
    }

    void specific_op_2() override {
        std::cout << "ConcreteImpl2执行专属操作2\n";
    }
};

步骤3：存入基类vector并使用 #

现在你就可以把具体类的指针存入基类vector了，和你之前存普通派生类的逻辑一致：

int main() {
    std::vector<interface*> intf_vec;

    // 存入具体类的指针（抽象类的最终派生类）
    intf_vec.push_back(new ConcreteImpl1());
    intf_vec.push_back(new ConcreteImpl2());

    // 多态调用核心方法
    for (auto ptr : intf_vec) {
        ptr->core_operation();
        
        // 如果需要调用抽象派生类的专属方法，可以用dynamic_cast做类型转换
        if (auto ad1_ptr = dynamic_cast<abstract_derived_1*>(ptr)) {
            ad1_ptr->specific_op_1();
        } else if (auto ad2_ptr = dynamic_cast<abstract_derived_2*>(ptr)) {
            ad2_ptr->specific_op_2();
        }
    }

    // 手动释放内存（记得基类析构是virtual，不然会泄漏）
    for (auto ptr : intf_vec) {
        delete ptr;
    }
    intf_vec.clear();

    return 0;
}

额外建议：用智能指针避免手动内存管理 #

如果你不想手动处理delete，推荐用std::unique_ptr或者std::shared_ptr，它们会自动管理内存，更安全：

#include <memory>

int main() {
    std::vector<std::unique_ptr<interface>> intf_vec;

    // 用make_unique创建具体类对象，自动存入智能指针
    intf_vec.push_back(std::make_unique<ConcreteImpl1>());
    intf_vec.push_back(std::make_unique<ConcreteImpl2>());

    // 用法和普通指针一致，不用手动delete
    for (const auto& ptr : intf_vec) {
        ptr->core_operation();
    }

    return 0;
}

内容的提问来源于stack exchange，提问作者b._.rett