C++类如何判定析构时无需释放内存 解决空悬指针问题

你遇到的空悬指针问题，本质和析构函数要不要释放内存无关——你存的指针指向的是生命周期已经结束的栈对象。
你写的构造函数、赋值运算符都是值传参，比如MyContainer(MyClassA x)里的x是函数栈上的临时形参，函数执行完x就会被销毁，栈帧回收后这块内存会被后续函数调用复用，你把&x存到成员指针里，不管怎么修改析构逻辑，这个指针都是野指针，访问就会触发未定义行为。

你设想的i_am_a_pointee标记位从设计上就存在无法解决的缺陷：

• 没有可靠的赋值时机：你没法自动识别哪个对象需要被指针长期持有、不需要析构释放资源，手动赋值极易出现漏标、错标。如果给栈上的局部变量错加标记，会导致局部变量离开作用域时不释放持有的资源，直接造成内存泄漏。
• 就算给临时形参x加上标记，让它析构时不释放堆上资源，x本身是栈上分配的对象，构造函数返回后它占用的栈内存就会被系统回收，你存的地址指向的内存随时会被其他栈数据覆盖，和析构是否释放堆资源没有任何关系。
• 所有权语义完全混乱：你没法清晰区分“对象是容器自己动态分配的，需要容器负责释放”和“对象是外部传入的，容器只是借用指针、无权释放”两种场景，代码稍有不慎就会出现重复释放或者内存泄漏。

根据你要实现“可承载多种不同类实例的容器”的需求，有几种成熟的工业级实现方式，完全不需要手写易错的标记位逻辑：

方案1：容器持有对象所有权，自行管理生命周期 #

如果需要容器完全掌控存储对象的生命周期，就不要存外部临时形参的栈地址，而是在接收传入对象时，在堆上动态拷贝构造一份副本，容器自己负责副本的释放。
基础版本手动管理内存的示例：

class MyClassA {
public:
    MyClassA() = default;
    ~MyClassA() { /* 释放自身持有的资源 */ }
    // 记得正确实现拷贝构造，避免浅拷贝问题
    MyClassA(const MyClassA&) = default;
};
class MyClassB {
public:
    MyClassB() = default;
    ~MyClassB() { /* 释放自身持有的资源 */ }
    MyClassB(const MyClassB&) = default;
};

class MyContainer {
    MyClassA* m_class_a = nullptr;
    MyClassB* m_class_b = nullptr;
public:
    MyContainer() = default;

    MyContainer(const MyClassA& x) {
        m_class_a = new MyClassA(x);
    }
    MyContainer& operator=(const MyClassA& x) {
        // 先释放之前存储的旧对象
        delete m_class_a;
        m_class_b = nullptr;
        // 堆上拷贝新对象
        m_class_a = new MyClassA(x);
        return *this;
    }

    MyContainer(const MyClassB& x) {
        m_class_b = new MyClassB(x);
    }
    MyContainer& operator=(const MyClassB& x) {
        delete m_class_b;
        m_class_a = nullptr;
        m_class_b = new MyClassB(x);
        return *this;
    }

    operator MyClassA() {
        return *m_class_a;
    }
    operator MyClassB() {
        return *m_class_b;
    }

    ~MyContainer() {
        delete m_class_a;
        delete m_class_b;
    }

    // 额外需要正确实现拷贝构造、拷贝赋值、移动构造、移动赋值，避免浅拷贝导致重复释放
};

不想手动管理new/delete的话，可以直接用标准库的智能指针std::unique_ptr，它会自动在对象离开作用域时释放资源，不需要手写析构函数，也不用手动处理拷贝移动逻辑：

#include <memory>
class MyContainer {
    std::unique_ptr<MyClassA> m_class_a;
    std::unique_ptr<MyClassB> m_class_b;
public:
    MyContainer() = default;

    MyContainer& operator=(const MyClassA& x) {
        m_class_a = std::make_unique<MyClassA>(x);
        m_class_b.reset();
        return *this;
    }
    MyContainer& operator=(const MyClassB& x) {
        m_class_b = std::make_unique<MyClassB>(x);
        m_class_a.reset();
        return *this;
    }

    operator MyClassA() { return *m_class_a; }
    operator MyClassB() { return *m_class_b; }
};

方案2：容器不持有所有权，仅借用外部对象指针 #

如果容器不需要管理对象的生命周期，只是临时访问外部已经存在的对象，就把值传参改成引用传参，存储外部对象的地址，由调用方保证传入对象的生命周期比容器长，容器析构时不需要释放这些指针。
示例代码：

class MyContainer {
    MyClassA* m_class_a = nullptr;
    MyClassB* m_class_b = nullptr;
public:
    MyContainer() = default;

    MyContainer& operator=(MyClassA& x) {
        m_class_a = &x;
        m_class_b = nullptr;
        return *this;
    }
    MyContainer& operator=(MyClassB& x) {
        m_class_b = &x;
        m_class_a = nullptr;
        return *this;
    }

    operator MyClassA() { return *m_class_a; }
    operator MyClassB() { return *m_class_b; }

    // 不需要写析构释放逻辑，指针指向的对象由外部管理
    ~MyContainer() = default;
};

这种方案下你写的main逻辑可以正常运行，只需要修正原来的语法错误（MyClassB = container漏了变量名）：

int main() {
    MyContainer container;
    MyClassA a;
    MyClassB b;
    container = a; // 存a的地址，a在main函数结束前都不会销毁
    MyClassA a1 = container;
    container = b; // 存b的地址
    MyClassB b1 = container;
}

方案3：使用标准库现成的多态容器（C++17及以上） #

如果后续需要支持更多存储类型，每次修改容器的成员指针会非常繁琐，C++17提供的std::variant天生就是用来实现“同一时间持有多种类型中某一种实例”的类型安全容器，不需要手动管理任何指针内存，自动处理对象的构造、析构、拷贝逻辑，完全不会出现空悬指针问题：

#include <variant>
class MyContainer {
    // std::monostate代表空状态，即容器没有存任何对象
    std::variant<std::monostate, MyClassA, MyClassB> m_data;
public:
    MyContainer() = default;

    MyContainer& operator=(const MyClassA& x) {
        m_data = x;
        return *this;
    }
    MyContainer& operator=(const MyClassB& x) {
        m_data = x;
        return *this;
    }

    operator MyClassA() { return std::get<MyClassA>(m_data); }
    operator MyClassB() { return std::get<MyClassB>(m_data); }
};

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