自定义C++对象池与内存对齐：是否需用std::aligned_alloc替换malloc？

是的，你必须替换std::malloc为std::aligned_alloc（或其他能保证正确对齐的内存分配方式），这正是你代码运行效果不理想的核心原因。

原代码的关键问题 #

1. 内存对齐不满足要求
   std::malloc仅保证返回的内存满足系统默认的最大基础对齐（对应alignof(std::max_align_t)），但如果你的T类型有更高的对齐要求（比如包含SIMD成员、用alignas指定了更大的对齐值），直接用malloc分配的内存会导致对象构造在未对齐的地址上，触发未定义行为——这可能表现为崩溃、性能骤降或逻辑异常。

2. 扩容时的对象拷贝错误
   原代码用std::memcpy直接拷贝已构造的对象，这仅对平凡可复制类型有效。如果T是非平凡类型（比如有自定义拷贝构造函数、包含智能指针等非平凡成员），memcpy会直接破坏对象的内部状态，同样引发未定义行为。

修复后的实现代码 #

#include <cstdlib>
#include <new>
#include <utility>

template<class T>
struct AlwaysGrowingPool
{
    AlwaysGrowingPool() : used(0), capacity(1)
    {
        const std::size_t align = alignof(T);
        const std::size_t total_size = capacity * sizeof(T);
        // aligned_alloc要求内存大小是对齐值的整数倍，这里sizeof(T)已满足该条件
        p_mem = static_cast<unsigned char*>(std::aligned_alloc(align, total_size));
        if (!p_mem) {
            throw std::bad_alloc();
        }
    }

    ~AlwaysGrowingPool()
    {
        // 逆序析构对象，符合构造顺序的逆序规则
        for (std::size_t i = used; i > 0; --i) {
            reinterpret_cast<T*>(&p_mem[(i-1) * sizeof(T)])->~T();
        }
        std::free(p_mem); // aligned_alloc分配的内存用free释放即可
    }

    // 禁用拷贝/移动，避免内存管理混乱
    AlwaysGrowingPool(const AlwaysGrowingPool&) = delete;
    AlwaysGrowingPool& operator=(const AlwaysGrowingPool&) = delete;
    AlwaysGrowingPool(AlwaysGrowingPool&&) = delete;
    AlwaysGrowingPool& operator=(AlwaysGrowingPool&&) = delete;

    template<class... Args>
    T* create(Args&&... args)
    {
        if (used == capacity) {
            const std::size_t new_capacity = capacity * 2;
            const std::size_t align = alignof(T);
            const std::size_t new_total_size = new_capacity * sizeof(T);
            unsigned char* p_new_mem = static_cast<unsigned char*>(std::aligned_alloc(align, new_total_size));
            if (!p_new_mem) {
                throw std::bad_alloc();
            }

            // 逐个移动/拷贝构造对象到新内存，而非直接memcpy
            for (std::size_t i = 0; i < used; ++i) {
                T* old_obj = reinterpret_cast<T*>(&p_mem[i * sizeof(T)]);
                new (&p_new_mem[i * sizeof(T)]) T(std::move(*old_obj));
                old_obj->~T(); // 析构旧内存中的对象
            }

            std::free(p_mem);
            p_mem = p_new_mem;
            capacity = new_capacity;
        }

        T* new_obj = new (&p_mem[used * sizeof(T)]) T(std::forward<Args>(args)...);
        ++used;
        return new_obj;
    }

    std::size_t used;
    std::size_t capacity;
    unsigned char* p_mem;
};

修复要点说明 #

• 对齐保证：用std::aligned_alloc明确指定T的对齐要求，确保所有对象都构造在符合对齐规则的地址上。
• 正确的对象迁移：扩容时通过移动（或拷贝）构造函数重新创建对象，再析构旧对象，避免memcpy的安全隐患。
• 禁用拷贝/移动：防止因池对象被拷贝或移动导致的内存泄漏、双重释放问题。
• 逆序析构：遵循C++中对象构造与析构的顺序规则，避免依赖顺序的成员出现析构错误。

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