什么是C++的placement delete 与placement new配对的特殊用法

#include <iostream>
#include <new> // 必须包含这个头文件

class MyClass {
public:
    MyClass(int value) : data(value) {
        std::cout << "Constructor called, data = " << data << std::endl;
    }
    ~MyClass() {
        std::cout << "Destructor called, data = " << data << std::endl;
    }
    int data;
};

int main() {
    // 1. 分配原始内存
    void* buffer = operator new(sizeof(MyClass));

    // 2. 使用 placement new 在 buffer 上构造 MyClass 对象
    MyClass* obj = new (buffer) MyClass(42); // 注意这里的 new 语法

    // 3. 使用对象
    std::cout << "Object data: " << obj->data << std::endl;

    // 4. 使用 placement delete 析构对象 (显式调用析构函数)
    obj->~MyClass();

    // 5. 释放原始内存
    operator delete(buffer);

    return 0;
}

#include <iostream>
#include <new>

class MyClass {
public:
    MyClass(int value) : data(value) {
        std::cout << "Constructor called, data = " << data << std::endl;
    }
    ~MyClass() {
        std::cout << "Destructor called, data = " << data << std::endl;
    }
    int data;
};

// 自定义 placement delete (可选)
void operator delete(void* ptr, MyClass* obj) {
    std::cout << "Custom placement delete called" << std::endl;
    obj->~MyClass(); // 显式调用析构函数
    operator delete(ptr); // 释放内存 (如果需要)
}


int main() {
    // 1. 分配原始内存
    void* buffer = operator new(sizeof(MyClass));

    // 2. 使用 placement new 在 buffer 上构造 MyClass 对象
    MyClass* obj = new (buffer) MyClass(42);

    // 3. 使用对象
    std::cout << "Object data: " << obj->data << std::endl;

    // 4. 显式调用析构函数 (相当于 placement delete)
    obj->~MyClass(); // 或者使用自定义的 placement delete (如果定义了)
    // delete obj; //错误！不能这样使用 delete

    // 5. 释放原始内存
    operator delete(buffer);

    return 0;
}

// 普通 new
MyClass* obj = new MyClass(42); // 分配内存 + 构造对象
delete obj; // 析构对象 + 释放内存

// placement new
void* buffer = operator new(sizeof(MyClass)); // 分配内存 (单独操作)
MyClass* obj = new (buffer) MyClass(42); // 只构造对象
obj->~MyClass(); // 只析构对象
operator delete(buffer); // 释放内存 (单独操作)

#include <iostream>
#include <new>

class MyClass {
public:
    MyClass(int value) : data(value) {
        std::cout << "Constructor called, data = " << data << std::endl;
    }
    ~MyClass() {
        std::cout << "Destructor called, data = " << data << std::endl;
    }
    int data;
};

class PlacementNewWrapper {
public:
    PlacementNewWrapper(size_t size) : buffer(operator new(size)), object(nullptr), size(size) {}

    template <typename T, typename... Args>
    T* construct(Args&&... args) {
        object = new (buffer) T(std::forward<Args>(args)...);
        return static_cast<T*>(object);
    }

    ~PlacementNewWrapper() {
        if (object) {
            static_cast<MyClass*>(object)->~MyClass(); // 显式调用析构函数
        }
        operator delete(buffer); // 释放内存
    }

private:
    void* buffer;
    void* object;
    size_t size;
};

int main() {
    PlacementNewWrapper wrapper(sizeof(MyClass));
    MyClass* obj = wrapper.construct<MyClass>(42);

    std::cout << "Object data: " << obj->data << std::endl;

    // 析构函数和内存释放会在 wrapper 析构时自动完成
    return 0;
}

void operator delete(void* ptr, MyClass* obj);