C++ `Placement Delete` 与 `Placement New` 的结合使用：精确内存控制

哈喽，各位好！今天咱们来聊聊C++里一对有点儿“特立独行”的家伙：Placement New 和 Placement Delete。别被它们的名字吓到，其实它们是C++里实现精确内存控制的利器。

第一部分：Placement New，指定位置的建筑师

想象一下，你是一个建筑师，普通 new 操作符就像是让你随便找块地盖房子，盖在哪里你说了不算，操作系统说了算。但是，如果有一天，老板告诉你：“嘿，小伙子，这次的房子必须盖在指定的位置，就在那块已经平整好的地基上！” 这时候，你就需要 Placement New 了。

Placement New 的作用就是在已经分配好的内存上构造对象。它的语法看起来有点奇怪：

#include <iostream>

using namespace std;

class MyClass {
public:
    MyClass(int value) : m_value(value) {
        cout << "MyClass constructor called, value = " << m_value << endl;
    }
    ~MyClass() {
        cout << "MyClass destructor called, value = " << m_value << endl;
    }

    int getValue() const { return m_value; }

private:
    int m_value;
};

int main() {
    // 1. 先分配一块内存，注意这里分配的是 raw memory，没有类型信息
    void* buffer = operator new(sizeof(MyClass));

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

    // 3. 使用对象
    cout << "Object value: " << obj->getValue() << endl;

    // 4. 销毁对象 (重点！)
    obj->~MyClass(); // 显示调用析构函数

    // 5. 释放内存 (重点！)
    operator delete(buffer);

    return 0;
}

代码解释：

1. *`void buffer = operator new(sizeof(MyClass));**: 这行代码使用operator new（注意，不是普通的new MyClass）分配了一块足够容纳MyClass对象的内存。operator new只负责分配内存，它不调用构造函数。返回的是一个void*` 指针，指向分配的原始内存。
2. *`MyClass obj = new (buffer) MyClass(42);**: 这就是 Placement New 的闪亮登场！new (buffer) MyClass(42)的意思是：在buffer指向的内存上，调用MyClass的构造函数，创建一个MyClass对象。 注意new` 关键字后面的括号里放的是内存地址。
3. cout << "Object value: " << obj->getValue() << endl;: 没啥好说的，正常使用对象。
4. obj->~MyClass();: 这是Placement New最关键的地方之一！ 因为内存是我们自己分配的，所以对象销毁的时候，需要手动调用析构函数。如果不手动调用，对象占用的资源（例如动态分配的内存）就无法释放，导致内存泄漏。
5. operator delete(buffer);: 这是Placement New最关键的地方之二！ 内存也是我们自己分配的，所以需要手动释放内存。 这里使用 operator delete 来释放之前分配的原始内存。

为什么需要 Placement New？

• 性能优化: 在某些情况下，预先分配一块大的内存，然后使用 Placement New 在这块内存上反复构造和析构对象，可以避免频繁的内存分配和释放，提高性能。 比如游戏引擎中的对象池。
• 内存对齐: 可以控制对象的内存对齐方式，提高数据访问效率。
• 自定义内存管理: 可以结合自定义的内存分配器，实现更精细的内存管理策略。 比如，使用共享内存进行进程间通信时，需要在共享内存的特定位置构造对象。

第二部分：Placement Delete，善后处理大师（但其实并不存在！）

你可能会想，既然有 Placement New，那是不是也应该有个 Placement Delete？ 答案是：并没有Placement Delete这个东西！

为什么？ 因为 Placement New 只是在已有的内存上构造对象，并没有分配新的内存。相应的，销毁对象只需要调用析构函数，然后释放之前分配的原始内存即可。

Placement Delete 的 “替代品”

虽然没有直接的 Placement Delete，但我们有“替代方案”，也就是上面代码中的：

obj->~MyClass(); // 显示调用析构函数
operator delete(buffer); // 释放内存

这两步操作完成了 Placement Delete 应该做的事情：

1. obj->~MyClass();: 显式调用对象的析构函数，释放对象占用的资源。
2. operator delete(buffer);: 释放之前使用 operator new 分配的原始内存。

重点强调：如果使用 Placement New，一定要记得手动调用析构函数和释放内存！

第三部分：Placement New 的高级用法：对象池

对象池是一种常用的内存管理技术，它可以预先分配一块内存，然后在这块内存上反复构造和析构对象，避免频繁的内存分配和释放。 Placement New 非常适合用于实现对象池。

下面是一个简单的对象池的例子：

#include <iostream>
#include <vector>

using namespace std;

class MyObject {
public:
    MyObject(int id) : m_id(id) {
        cout << "MyObject constructor called, id = " << m_id << endl;
    }
    ~MyObject() {
        cout << "MyObject destructor called, id = " << m_id << endl;
    }

    int getId() const { return m_id; }

private:
    int m_id;
};

class ObjectPool {
public:
    ObjectPool(size_t size) : m_poolSize(size) {
        // 分配一块大的内存
        m_pool = operator new(m_poolSize * sizeof(MyObject));
        m_used.resize(m_poolSize, false); // 标记哪些位置被使用
    }

    ~ObjectPool() {
        // 销毁所有对象
        for (size_t i = 0; i < m_poolSize; ++i) {
            if (m_used[i]) {
                MyObject* obj = reinterpret_cast<MyObject*>(static_cast<char*>(m_pool) + i * sizeof(MyObject));
                obj->~MyObject();
            }
        }
        // 释放内存
        operator delete(m_pool);
    }

    MyObject* acquire(int id) {
        // 找到一个空闲的位置
        for (size_t i = 0; i < m_poolSize; ++i) {
            if (!m_used[i]) {
                // 使用 placement new 在该位置构造对象
                MyObject* obj = new (static_cast<char*>(m_pool) + i * sizeof(MyObject)) MyObject(id);
                m_used[i] = true;
                return obj;
            }
        }
        // 没有空闲位置
        return nullptr;
    }

    void release(MyObject* obj) {
        // 找到对象在内存池中的位置
        size_t index = (static_cast<char*>(obj) - static_cast<char*>(m_pool)) / sizeof(MyObject);
        if (index >= 0 && index < m_poolSize && m_used[index]) {
            // 销毁对象
            obj->~MyObject();
            m_used[index] = false;
        }
    }

private:
    void* m_pool;  // 内存池的起始地址
    size_t m_poolSize; // 内存池的大小
    vector<bool> m_used; // 记录每个位置是否被使用
};

int main() {
    // 创建一个大小为 3 的对象池
    ObjectPool pool(3);

    // 从对象池中获取对象
    MyObject* obj1 = pool.acquire(1);
    MyObject* obj2 = pool.acquire(2);
    MyObject* obj3 = pool.acquire(3);
    MyObject* obj4 = pool.acquire(4); // 没有空闲位置，返回 nullptr

    if (obj1) cout << "obj1 id: " << obj1->getId() << endl;
    if (obj2) cout << "obj2 id: " << obj2->getId() << endl;
    if (obj3) cout << "obj3 id: " << obj3->getId() << endl;
    if (obj4) cout << "obj4 is nullptr" << endl;

    // 释放对象
    pool.release(obj2);

    // 再次获取对象
    MyObject* obj5 = pool.acquire(5); // 现在有空闲位置了

    if (obj5) cout << "obj5 id: " << obj5->getId() << endl;

    return 0;
}

代码解释：

• ObjectPool 类: 封装了对象池的逻辑。
• m_pool: 指向预先分配的内存块。
• m_used: 一个 vector<bool>，用于记录内存池中每个位置是否被使用。
• acquire(int id): 从对象池中获取一个 MyObject 对象。 如果找到空闲位置，就使用 Placement New 在该位置构造对象，并返回对象的指针。 如果没有空闲位置，就返回 nullptr。
• *`release(MyObject obj)`**: 将对象返回到对象池中。 首先，找到对象在内存池中的位置，然后调用对象的析构函数，并将该位置标记为空闲。
• static_cast<char*>(m_pool) + i * sizeof(MyObject): 这行代码计算内存池中第 i 个对象的地址。 因为 m_pool 是 void* 类型，所以需要先将其转换为 char* 类型，才能进行指针运算。

对象池的优点：

• 提高性能: 避免频繁的内存分配和释放。
• 减少内存碎片: 由于对象的大小是固定的，所以可以减少内存碎片。
• 提高内存利用率: 可以重复使用已经分配的内存。

对象池的缺点：

• 需要预先分配内存: 如果对象池的大小设置不合理，可能会浪费内存。
• 线程安全问题: 如果多个线程同时访问对象池，需要进行同步处理。

第四部分：Placement New 与异常

当 Placement New 构造对象时，如果构造函数抛出异常，会发生什么？

这是一个比较 tricky 的问题。 如果构造函数抛出异常，Placement New 不会自动调用 operator delete 来释放之前分配的内存。 这意味着，你需要自己处理异常，并手动释放内存。

#include <iostream>
#include <stdexcept>

using namespace std;

class MyClass {
public:
    MyClass(int value) : m_value(value) {
        cout << "MyClass constructor called, value = " << m_value << endl;
        if (value < 0) {
            throw runtime_error("Value must be non-negative");
        }
    }
    ~MyClass() {
        cout << "MyClass destructor called, value = " << m_value << endl;
    }

    int getValue() const { return m_value; }

private:
    int m_value;
};

int main() {
    void* buffer = operator new(sizeof(MyClass));
    MyClass* obj = nullptr;

    try {
        obj = new (buffer) MyClass(-1); // 构造函数抛出异常
        cout << "Object value: " << obj->getValue() << endl; // 这行代码不会执行
    } catch (const exception& e) {
        cerr << "Exception caught: " << e.what() << endl;
        // 关键：如果构造函数抛出异常，需要手动调用析构函数和释放内存
        if (obj) {
            obj->~MyClass();
        }
        operator delete(buffer);
        return 1;
    }

    // 如果构造函数没有抛出异常，需要正常销毁对象和释放内存
    obj->~MyClass();
    operator delete(buffer);

    return 0;
}

代码解释：

• try...catch 块: 用于捕获构造函数抛出的异常。
• if (obj) { obj->~MyClass(); }: 在 catch 块中，需要判断 obj 是否已经被构造。 如果已经被构造（即使只构造了一部分），就需要手动调用析构函数来释放对象占用的资源。 注意，这里需要判断 obj 是否为 nullptr，因为如果 new (buffer) 操作本身就失败了（例如，buffer 为 nullptr），那么 obj 就不会被赋值。
• operator delete(buffer);: 无论构造函数是否抛出异常，都需要释放之前分配的原始内存。

处理 Placement New 异常的建议：

• 使用 RAII (Resource Acquisition Is Initialization): 将内存分配和对象构造封装到一个 RAII 对象中，在 RAII 对象的析构函数中释放内存，可以确保即使构造函数抛出异常，内存也能被正确释放。
• 谨慎使用 Placement New: 如果不是必须，尽量避免使用 Placement New。 使用普通的 new 操作符可以简化代码，并减少出错的可能性。

第五部分：Placement New 与数组

Placement New 也可以用于构造数组。 但是，需要注意的是，不能使用 new[] 操作符来分配内存，而是需要使用 operator new[]。

#include <iostream>

using namespace std;

class MyClass {
public:
    MyClass(int value) : m_value(value) {
        cout << "MyClass constructor called, value = " << m_value << endl;
    }
    ~MyClass() {
        cout << "MyClass destructor called, value = " << m_value << endl;
    }

    int getValue() const { return m_value; }

private:
    int m_value;
};

int main() {
    size_t arraySize = 3;
    // 1. 分配足够大的内存来存储数组
    void* buffer = operator new[](arraySize * sizeof(MyClass));

    // 2. 使用 placement new 构造数组中的每个对象
    MyClass* array = static_cast<MyClass*>(buffer); // 转换为MyClass*类型
    for (size_t i = 0; i < arraySize; ++i) {
        new (array + i) MyClass(i + 1);
    }

    // 3. 使用数组
    for (size_t i = 0; i < arraySize; ++i) {
        cout << "Array element " << i << " value: " << array[i].getValue() << endl;
    }

    // 4. 销毁数组中的每个对象 (逆序！)
    for (int i = arraySize - 1; i >= 0; --i) {
        array[i].~MyClass();
    }

    // 5. 释放内存
    operator delete[](buffer);

    return 0;
}

代码解释：

• *`operator new[](arraySize sizeof(MyClass))**: 使用operator new[]` 分配一块足够大的内存来存储数组。
• new (array + i) MyClass(i + 1): 使用 Placement New 在数组的每个位置构造对象。
• for (int i = arraySize - 1; i >= 0; --i) { array[i].~MyClass(); }: 重要： 销毁数组中的对象时，需要按照逆序调用析构函数。 这是因为如果对象的构造顺序依赖于之前的对象，那么销毁的顺序也应该是相反的。
• operator delete[](buffer): 使用 operator delete[] 释放之前分配的内存。

总结：

操作	普通 New	Placement New
内存分配	自动	手动 (operator new)
对象构造	自动 (构造函数)	手动 (new (buffer) MyClass(…))
对象销毁	自动 (析构函数)	手动 (obj->~MyClass())
内存释放	自动	手动 (operator delete)
异常处理	自动	手动 (需要考虑构造函数抛出异常的情况)
使用场景	一般的对象创建	对象池，内存对齐，自定义内存管理等

Placement New 和 “假装存在的Placement Delete” 是C++中进行底层内存控制的强大工具。掌握它们可以让你更灵活地管理内存，提高程序的性能和效率。但是，使用它们也需要格外小心，确保正确地分配和释放内存，并处理好异常情况。希望今天的讲解对大家有所帮助！ 记住：小心驶得万年船！