C++中为过度对齐类型获取正确对齐堆内存的方法

问题背景 #

在部分场景中，需先分配内存再在其中创建对象，此时会用到placement new：

T *pobj = new(pstorage);

但必须保证pstorage是正确对齐的。已知以下代码无法保证对过度对齐类型有效：

// 试图分配能容纳N个连续T对象的对齐堆内存，但对过度对齐类型无效
unsigned char *storage = new unsigned char[N*sizeof(T)];

针对过度对齐类型的operator new重载无法显式使用。目前找到的最简方案仅适用于对象数量编译期已知的情况：

// 类似std::aligned_storage的实现，可用于栈或堆
template <typename T, std::size_t N>
struct Storage {
    alignas(T) unsigned char storage[N * sizeof(T)];
};

auto *wrapped_storage = new Storage<T,N>;
auto *storage = wrapped_storage.storage;

解决方案（支持运行时确定对象数量） #

方案1：C++17及以后——带对齐参数的operator new #

C++17引入了支持显式指定对齐的operator new重载，直接分配符合类型对齐要求的内存：

#include <new>

// 运行时确定对象数量
std::size_t obj_count = /* 运行时计算的数值 */;
std::size_t total_size = obj_count * sizeof(T);
std::align_val_t align_requirement = std::align_val_t(alignof(T));

// 分配对齐内存
unsigned char* raw_storage = static_cast<unsigned char*>(operator new(total_size, align_requirement));

// 使用placement new构造对象
for (std::size_t i = 0; i < obj_count; ++i) {
    new (raw_storage + i * sizeof(T)) T(/* 传入构造参数 */);
}

// 销毁对象+释放内存
for (std::size_t i = obj_count; i > 0; --i) {
    (raw_storage + (i-1)*sizeof(T))->~T();
}
// 必须使用带对齐参数的operator delete重载，避免未定义行为
operator delete(raw_storage, total_size, align_requirement);

方案2：C++17及以后——std::aligned_alloc #

std::aligned_alloc是C标准库的对齐内存分配函数，C++17将其纳入标准：

#include <cstdlib>

std::size_t obj_count = /* 运行时数值 */;
std::size_t align = alignof(T);
std::size_t total_size = obj_count * sizeof(T);

// std::aligned_alloc要求总大小必须是对齐值的整数倍，若不满足则向上取整
if (total_size % align != 0) {
    total_size = (total_size / align + 1) * align;
}

unsigned char* raw_storage = static_cast<unsigned char*>(std::aligned_alloc(align, total_size));

// 构造对象逻辑同上
// ...

// 销毁对象后用free释放，不能用delete
free(raw_storage);

注意：std::aligned_alloc要求对齐值是2的幂，否则会返回空指针。

方案3：POSIX系统（C++11/14）——posix_memalign #

如果使用C++11/14且运行在POSIX兼容系统（如Linux、macOS），可以用posix_memalign：

#include <cstdlib>

std::size_t obj_count = /* 运行时数值 */;
std::size_t align = alignof(T);
std::size_t total_size = obj_count * sizeof(T);
unsigned char* raw_storage = nullptr;

// posix_memalign要求对齐值是sizeof(void*)的整数倍且为2的幂
int alloc_result = posix_memalign(reinterpret_cast<void**>(&raw_storage), align, total_size);
if (alloc_result != 0) {
    // 处理内存分配失败的逻辑
}

// 构造对象逻辑同上
// ...

// 销毁对象后用free释放
free(raw_storage);

核心注意事项 #

• 所有方案必须保证内存对齐满足alignof(T)，否则构造过度对齐类型会触发未定义行为。
• 内存释放必须匹配分配方式：operator new对应带对齐参数的operator delete，std::aligned_alloc/posix_memalign对应free，严禁混用。
• 若要容纳N个连续T对象，总内存大小至少为N * sizeof(T)，部分分配函数会要求总大小是对齐值的整数倍，需额外处理。

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