C++智能指针向上转型释放对象报错的原因与解决方法咨询

嘿，这个问题我之前也碰到过，咱们一步步拆解来看～

1. 浅拷贝导致的重复释放内存 #

你的SmartPointer类目前没处理拷贝构造和赋值运算符，C++会自动生成默认的版本——这些默认版本只会简单拷贝内部的裸指针ptr。当你把派生类指针向上转型为基类指针、并用SmartPointer管理后，如果不小心复制了这个智能指针（比如赋值给另一个SmartPointer对象，或者传参时没加引用），就会出现多个SmartPointer指向同一块内存的情况。等这些对象陆续析构时，每个都会执行delete ptr，第一次delete后内存已经被释放，第二次delete就会触发你看到的“被释放的对象未分配内存”错误。

举个直观的例子：

class Base {};
class Derived : public Base {};

SmartPointer<Base> sp1(new Derived);
SmartPointer<Base> sp2 = sp1; // 浅拷贝，sp1和sp2的ptr指向同一个对象
// 当sp1和sp2析构时，会两次delete同一个指针，直接触发错误

2. 多态场景下基类析构非虚的隐性问题 #

虽然这不是你当前错误的直接原因，但也是多态用智能指针的常见坑：如果你的基类Base析构函数不是virtual的，那用SmartPointer<Base>管理Derived对象时，析构时执行delete ptr（此时ptr是Base*类型），只会调用Base的析构，不会触发Derived的析构，这会导致派生类部分的内存泄漏，后续也可能引发其他问题。

1. 做独占式智能指针：禁用拷贝，支持移动 #

如果你想实现类似std::unique_ptr的独占式智能指针，核心是禁止拷贝，只允许通过移动语义转移所有权，这样就能避免多个指针共享同一块内存：

template <class T>
class SmartPointer{
    T* ptr = nullptr;
public:
    explicit SmartPointer(T* t):ptr(t){}
    virtual ~SmartPointer(){
        delete ptr;
        ptr = nullptr; // 置空避免野指针残留
    }

    // 直接禁用拷贝构造和赋值
    SmartPointer(const SmartPointer&) = delete;
    SmartPointer& operator=(const SmartPointer&) = delete;

    // 实现移动构造，让智能指针可以转移所有权
    SmartPointer(SmartPointer&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr; // 把原指针置空，避免原对象析构时重复释放
    }

    // 实现移动赋值
    SmartPointer& operator=(SmartPointer&& other) noexcept {
        if (this != &other) {
            delete ptr; // 先释放当前对象的内存
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        return *this;
    }

    // 重载指针运算符，模拟原生指针的行为
    T* operator->() const { return ptr; }
    T& operator*() const { return *ptr; }
};

这样你就不能直接拷贝SmartPointer对象了，只能用std::move()转移所有权，从根源上避免重复释放。

2. 做共享式智能指针：加引用计数 #

如果需要多个智能指针共享同一个对象的所有权，可以给智能指针加个引用计数，只有当最后一个指针析构时，才真正释放内存：

template <class T>
class SmartPointer{
    T* ptr = nullptr;
    size_t* ref_count = nullptr; // 用指针存引用计数，方便多个指针共享
public:
    explicit SmartPointer(T* t):ptr(t){
        if (ptr) {
            ref_count = new size_t(1); // 新对象引用计数初始为1
        }
    }

    // 拷贝构造：共享指针，引用计数+1
    SmartPointer(const SmartPointer& other) : ptr(other.ptr), ref_count(other.ref_count) {
        if (ref_count) {
            (*ref_count)++;
        }
    }

    // 赋值运算符：先释放当前对象，再共享新对象的指针和计数
    SmartPointer& operator=(const SmartPointer& other) {
        if (this != &other) {
            release(); // 先处理当前对象的引用计数
            ptr = other.ptr;
            ref_count = other.ref_count;
            if (ref_count) {
                (*ref_count)++;
            }
        }
        return *this;
    }

    virtual ~SmartPointer(){
        release();
    }

    // 辅助函数：处理引用计数和内存释放
    void release() {
        if (ref_count && --(*ref_count) == 0) { // 引用计数减到0时释放内存
            delete ptr;
            delete ref_count;
        }
        ptr = nullptr;
        ref_count = nullptr;
    }

    // 重载指针运算符
    T* operator->() const { return ptr; }
    T& operator*() const { return *ptr; }
};

这种方式下，不管你怎么拷贝、转型，只要还有智能指针指向对象，内存就不会被释放，只有最后一个指针析构时才会清理，完美解决重复释放的问题。

3. 多态场景必做：基类析构设为虚函数 #

如果你是在多态场景下用智能指针，一定要给基类加虚析构函数，这样delete基类指针时，会正确调用派生类的析构函数，避免内存泄漏：

class Base {
public:
    virtual ~Base() = default; // 虚析构函数，确保多态析构正确
};

class Derived : public Base {
    // ... 你的派生类成员
};

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