C++ vector存储派生类实例时raw指针提前释放问题及解决方案

你遇到的问题核心是违反了C++的三五法则：类A持有裸指针资源，自定义了析构函数执行释放操作，但只实现了浅拷贝的拷贝构造函数，没有对应的拷贝赋值、移动构造、移动赋值逻辑，导致多个类A实例持有同一个裸指针地址，任意一个实例销毁时都会释放指针指向的Kernel实例，其余实例持有的指针直接变为野指针。

你调试观察到的现象原因非常明确：使用初始化列表构造std::vector<D>时，初始化列表中的所有元素都是临时对象，vector会先拷贝这些临时对象到自身管理的内存空间，随后临时对象生命周期结束触发析构，临时对象持有的Kernel指针就被提前释放，vector内存储的对象持有的同地址指针自然变为野指针。

另外注意：如果BaseKernel没有定义虚析构函数，delete BaseKernel*指向的DerivedKernel实例还会触发未定义行为，这个问题不管用不用智能指针都要先修复。

如果坚持不使用智能指针，有三类可行方案，复杂度从低到高：

• 方案1：禁止类A的拷贝语义
  直接在类A的定义中将拷贝构造、拷贝赋值运算符声明为delete，同时按需实现移动语义：

class A {
public:
    A(BaseKernel* kernel) : kernel_(kernel) {}
    A(const A&) = delete;
    A& operator=(const A&) = delete;
    // 按需实现移动语义
    A(A&& other) noexcept : kernel_(std::exchange(other.kernel_, nullptr)) {}
    A& operator=(A&& other) noexcept {
        if (this != &other) {
            delete kernel_;
            kernel_ = std::exchange(other.kernel_, nullptr);
        }
        return *this;
    }
    ~A() { delete kernel_; }
private:
    BaseKernel* kernel_;
};

这种方案下Kernel实例的所有权唯一，你需要通过移动语义把对象放入容器，不会出现多个实例持有同一个指针的问题。

• 方案2：实现Kernel的深拷贝逻辑
  如果Kernel实例支持拷贝，你可以在类A的拷贝构造、拷贝赋值中创建Kernel的副本，保证每个类A实例持有独立的Kernel资源：

A(const A& other) : kernel_(other.kernel_->clone()) {}
A& operator=(const A& other) {
    if (this != &other) {
        delete kernel_;
        kernel_ = other.kernel_->clone();
    }
    return *this;
}

这里需要你在BaseKernel中定义纯虚的clone()接口，DerivedKernel实现该接口返回自身的拷贝。

• 方案3：手动实现引用计数
  如果确实需要多个类A实例共享同一个Kernel实例，你可以额外维护一个引用计数变量，拷贝时计数加1，析构时计数减1，只有计数归0时才释放Kernel：

class A {
public:
    A(BaseKernel* kernel) : kernel_(kernel), ref_count_(new int(1)) {}
    A(const A& other) : kernel_(other.kernel_), ref_count_(other.ref_count_) {
        (*ref_count_)++;
    }
    A& operator=(const A& other) {
        if (this != &other) {
            (*ref_count_)--;
            if (*ref_count_ == 0) {
                delete kernel_;
                delete ref_count_;
            }
            kernel_ = other.kernel_;
            ref_count_ = other.ref_count_;
            (*ref_count_)++;
        }
        return *this;
    }
    ~A() {
        (*ref_count_)--;
        if (*ref_count_ == 0) {
            delete kernel_;
            delete ref_count_;
        }
    }
private:
    BaseKernel* kernel_;
    int* ref_count_;
};

这种方案实现复杂度高，还需要额外处理线程安全问题，非常不推荐。

使用C++标准库的智能指针是成本最低、最不容易出错的方案，根据你的所有权需求二选一即可：

场景1：Kernel需要被多个实例共享 #

直接把类A的成员改为std::shared_ptr<BaseKernel>，不需要你手动实现任何构造、析构、赋值逻辑，编译器生成的默认函数会自动处理引用计数，只有最后一个持有Kernel的实例销毁时才会释放资源，完全解决提前释放和野指针问题：

class A {
public:
    A(std::shared_ptr<BaseKernel> kernel) : kernel_(std::move(kernel)) {}
    // 编译器自动生成的拷贝、移动、析构都符合要求
private:
    std::shared_ptr<BaseKernel> kernel_;
};

场景2：Kernel只属于单个实例独占 #

把类A的成员改为std::unique_ptr<BaseKernel>，编译器会自动删除拷贝构造和拷贝赋值，强制所有权唯一，你只需要通过移动语义把对象放入容器即可，不会出现重复释放的问题：

class A {
public:
    A(std::unique_ptr<BaseKernel> kernel) : kernel_(std::move(kernel)) {}
    // 编译器自动生成移动、析构逻辑，拷贝操作被禁用
private:
    std::unique_ptr<BaseKernel> kernel_;
};

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