C++ placement new 内存构造详解

Placement new 是 C++ 中用于在已分配内存上构造对象的特殊 new 运算符。1. 它不分配新内存，而是使用已有缓冲区构造对象；2. 使用后需手动调用析构函数并释放内存；3. 常用于内存池管理、自定义分配器、序列化及嵌入式系统；4. 其底层原理是重载 operator new，直接返回传入指针；5. 与常规 new 的区别在于仅构造对象而非分配内存；6. 避免内存泄漏的方法包括手动调用析构函数和使用 RAII 封装管理；7. 可结合自定义分配器实现高效内存控制，如固定大小块分配器。

placement new 是 C++ 中一种特殊的 new 运算符用法，它允许你在已分配的内存上构造对象，而不是像常规 new 那样分配新的内存。这在某些特定场景下非常有用，例如内存池管理、自定义内存分配器以及需要精确控制对象生命周期的情况。

解决方案

Placement new 的基本语法是：

void* buffer = malloc(sizeof(MyClass)); // 分配内存
MyClass* obj = new (buffer) MyClass(constructor_arguments); // 在 buffer 上构造 MyClass 对象

这里，new (buffer) MyClass(constructor_arguments) 就是 placement new 的使用方式。它不会分配新的内存，而是使用 buffer 指向的内存地址来构造 MyClass 对象。

需要注意的是，使用 placement new 构造的对象，其析构函数需要手动调用，并且需要手动释放内存（如果 buffer 是通过 malloc 等方式分配的）。

obj->~MyClass(); // 手动调用析构函数
free(buffer);     // 释放内存

使用 placement new 的场景

• 内存池管理： 当你需要频繁创建和销毁对象，但又不想每次都进行内存分配和释放时，可以使用内存池。内存池预先分配一块大的内存，然后使用 placement new 在这块内存上构造对象，避免了频繁的系统调用，提高了效率。
• 自定义内存分配器： 如果你需要自定义内存分配策略，例如使用特定的对齐方式或从特定的内存区域分配内存，可以使用 placement new 在自定义分配的内存上构造对象。
• 对象序列化和反序列化： 在对象序列化和反序列化过程中，可能需要在已分配的缓冲区中重新构造对象。Placement new 可以方便地实现这一点。
• 嵌入式系统： 在资源受限的嵌入式系统中，精确控制内存分配至关重要。Placement new 允许开发者在预先分配的内存区域中创建对象，避免动态内存分配带来的不确定性。

Placement new 的底层原理

Placement new 实际上是一个重载的 operator new 函数。通常情况下，operator new 负责分配内存并返回指向该内存的指针。而 placement new 版本的 operator new 只是简单地返回传入的指针，不做任何内存分配操作。构造对象的工作由构造函数完成，构造函数会在传入的内存地址上初始化对象。

副标题1：Placement new 与常规 new 的区别是什么？

常规 new 运算符负责两件事情：分配内存和构造对象。而 placement new 只负责构造对象，它假设内存已经分配好了。这意味着使用 placement new 需要手动分配和释放内存，而常规 new 则会自动处理这些事情。此外，常规 new 返回的是指向新分配内存的指针，而 placement new 返回的是传入的内存地址。一个很容易犯的错误是忘记手动调用析构函数和释放内存，导致内存泄漏或资源未释放。

副标题2：使用 Placement new 如何避免内存泄漏？

避免内存泄漏的关键在于确保每个使用 placement new 构造的对象都正确地调用了析构函数，并且分配的内存也被正确地释放。一种常见的做法是使用 RAII (Resource Acquisition Is Initialization) 技术，将内存分配和释放封装在一个类中，利用对象的生命周期来管理内存。例如：

template <typename T>
class PlacementNewWrapper {
public:
    PlacementNewWrapper(size_t size) : buffer_(malloc(size)), obj_(nullptr), size_(size) {}

    ~PlacementNewWrapper() {
        if (obj_) {
            obj_->~T();
        }
        free(buffer_);
    }

    T* construct(auto&&... args) {
        obj_ = new (buffer_) T(std::forward<decltype(args)>(args)...);
        return obj_;
    }

private:
    void* buffer_;
    T* obj_;
    size_t size_;
};

// 使用示例
PlacementNewWrapper<MyClass> wrapper(sizeof(MyClass));
MyClass* myObj = wrapper.construct(arg1, arg2);
// 不需要手动释放内存和调用析构函数，wrapper 对象销毁时会自动处理

副标题3：Placement new 在实现自定义内存分配器中的具体应用？

自定义内存分配器通常会维护一块大的内存池，然后根据需要从内存池中分配内存。Placement new 可以与自定义内存分配器结合使用，在分配到的内存块上构造对象。例如，可以实现一个简单的固定大小块分配器：

class FixedSizeAllocator {
public:
    FixedSizeAllocator(size_t blockSize, size_t blockCount) : blockSize_(blockSize), blockCount_(blockCount), memory_(malloc(blockSize * blockCount)), freeList_(nullptr) {
        char* current = static_cast<char*>(memory_);
        for (size_t i = 0; i < blockCount; ++i) {
            *reinterpret_cast<void**>(current) = freeList_;
            freeList_ = current;
            current += blockSize;
        }
    }

    ~FixedSizeAllocator() {
        free(memory_);
    }

    void* allocate() {
        if (!freeList_) {
            return nullptr; // 内存池已满
        }
        void* block = freeList_;
        freeList_ = *reinterpret_cast<void**>(freeList_);
        return block;
    }

    void deallocate(void* block) {
        *reinterpret_cast<void**>(block) = freeList_;
        freeList_ = block;
    }

private:
    size_t blockSize_;
    size_t blockCount_;
    void* memory_;
    void* freeList_;
};

// 使用示例
FixedSizeAllocator allocator(sizeof(MyClass), 10);
void* memory = allocator.allocate();
if (memory) {
    MyClass* obj = new (memory) MyClass(arg1, arg2);
    // ... 使用 obj ...
    obj->~MyClass();
    allocator.deallocate(memory);
}

在这个例子中，FixedSizeAllocator 管理一块固定大小的内存池，allocate 方法返回一个可用的内存块，deallocate 方法将内存块返回到内存池。Placement new 用于在 allocate 返回的内存块上构造 MyClass 对象。