C++自定义delete运算符实现：根据对象成员变量值决定是否执行内存释放

当然可以！你完全可以通过为类自定义operator delete来实现这个需求——让你能根据对象成员变量的值自主决定是否释放内存。不过这里有个关键的坑得先提一下，咱们一步步拆解来说。

首先得明确delete的执行流程，这是核心：

当你调用delete object时，C++运行时会按顺序做两件事：

1. 调用对象的析构函数（~MyType()）清理对象内部资源；
2. 调用operator delete释放对象占用的内存。

所以如果直接在operator delete里访问object->x，此时对象已经被析构了，这属于未定义行为（UB）——标准不保证x的值此时仍然有效。

接下来给你两种可行方案：

方案1：使用自定义销毁函数（最安全，首推） #

与其依赖默认的delete行为，不如写一个静态成员函数，在析构和释放内存之前先完成检查。这种方式完全避免了UB，逻辑也更清晰：

class MyType {
public:
    int x;

    // 自定义销毁函数，处理条件性内存释放
    static void destroy(MyType* obj) {
        if (!obj) return; // 防御空指针

        if (obj->x % 2 == 0) {
            // 如果x是偶数：先析构对象，再释放内存
            obj->~MyType();
            ::operator delete(obj);
        }
        // 如果x是奇数：什么都不做——保留内存
        // 注：如果你希望即使不释放内存也要执行析构，
        // 可以把`obj->~MyType();`移到if外面
    }
};

// 使用方式：
MyType* object = new MyType();
object->x = 3; // 奇数——内存不会被释放
MyType::destroy(object);

这种方案的优势在于完全安全，没有任何未定义行为，代码意图一目了然，用户能清楚知道调用的是自定义销毁逻辑。

方案2：自定义operator delete（需谨慎处理UB） #

如果你确实希望直接使用delete关键字，可以重载类专属的operator delete。但要解决对象在operator delete执行时已经被析构的问题，要么保证析构过程不修改x的值，要么提前存储x的备份，让它能在析构后依然可访问。

注意：直接访问析构后的对象成员属于UB，以下代码仅作演示，不推荐用于生产环境： #

class MyType {
public:
    int x;

    // 类专属的operator delete
    void operator delete(void* ptr) {
        MyType* obj = static_cast<MyType*>(ptr);
        // 警告：这里访问obj->x属于未定义行为！
        // 此时对象已经被析构了
        if (obj->x % 2 == 0) {
            // 调用全局operator delete释放内存
            ::operator delete(ptr);
        }
        // x为奇数时什么都不做——内存保留
    }
};

// 使用方式：
MyType* object = new MyType();
object->x = 4; // 偶数——内存会被释放
delete object;

更安全的自定义operator delete（结合自定义operator new） #

要彻底避免UB，可以在创建对象时分配额外内存存储x的备份，然后在operator delete里读取这个备份：

class MyType {
public:
    int x;

    // 自定义operator new：分配额外空间存储x的备份
    void* operator new(size_t size) {
        // 分配size + sizeof(int)的空间，同时容纳对象和x的备份
        char* raw_ptr = static_cast<char*>(::operator new(size + sizeof(int)));
        // 初始化备份为0
        *reinterpret_cast<int*>(raw_ptr) = 0;
        // 返回指向对象的指针（跳过备份空间）
        return raw_ptr + sizeof(int);
    }

    // 自定义operator delete：读取备份决定是否释放内存
    void operator delete(void* obj_ptr) {
        char* raw_ptr = static_cast<char*>(obj_ptr) - sizeof(int);
        int x_backup = *reinterpret_cast<int*>(raw_ptr);
        
        if (x_backup % 2 == 0) {
            ::operator delete(raw_ptr);
        }
        // x为奇数时保留内存
    }

    // 构造函数：初始化x时同步更新备份
    MyType() : x(0) {
        char* raw_ptr = static_cast<char*>(this) - sizeof(int);
        *reinterpret_cast<int*>(raw_ptr) = x;
    }

    // 重载赋值运算符：x修改时同步更新备份
    MyType& operator=(int new_x) {
        x = new_x;
        char* raw_ptr = static_cast<char*>(this) - sizeof(int);
        *reinterpret_cast<int*>(raw_ptr) = x;
        return *this;
    }
};

// 使用方式：
MyType* object = new MyType();
object->x = 5; // 奇数——内存不会被释放
delete object;

这个方案完全规避了UB，因为我们读取的是额外存储的x备份，而非已经析构的对象成员。

最后总结一下：
如果你看重简洁性和安全性，优先选择自定义销毁函数；如果必须直接使用delete关键字，结合自定义new和delete的方案是避免未定义行为的最安全方式。

内容的提问来源于stack exchange，提问作者M. Alexandru