我正在尝试分配一个大小为 size 的内存块，它需要 Alignment 对齐，而在编译时可能未定义大小。我知道存在 _aligned_alloc、posix_memalign、_mm_alloc 等例程，但我不想使用它们，因为它们会降低代码的可移植性。
C++11 提供了一个例程 std::align 和一个类 std::aligned_storage，我可以从中检索 POD 类型进行分配一个将符合我的要求的元素。然而，我的目标是创建一个分配器，它将分配一个 size 大小的内存块(不仅仅是单个元素)，该内存块将被对齐。
这可能使用 std::align 吗？我问的原因是因为 std::align 移动指针，使用该指针的类将为分配器提供指向移动地址的指针以进行释放，这将是无效的。有没有办法以这种方式创建 aligned_allocator？

最佳答案

编辑:经过 OP 的澄清后，原来的答案似乎跑题了；仅供引用，它保留在本答案的末尾。

实际上，答案很简单:您只需要保留一个指向存储 block 和第一项的指针即可。

这实际上不需要有状态的分配器(即使在 C++03 中也是可能的，尽管使用自定义 std::align 例程)。诀窍是分配器不需要只要求系统提供足够的内存来存储用户数据。它完全可以为了自己的簿记目的而要求多一点。

所以，我们在这里创建一个对齐的分配器；为简单起见，我将重点介绍分配/解除分配例程。

template <typename T>
class aligned_allocator {
    // Allocates block of memory:
    // - (opt) padding
    // - offset: ptrdiff_t
    // - T * n: T
    // - (opt) padding
public:
    typedef T* pointer;
    typedef size_t size_type;

    pointer allocate(size_type n);
    void deallocate(pointer p, size_type n);

}; // class aligned_allocator

现在是分配例程。大量内存摆弄，毕竟这是分配器的核心!

template <typename T>
auto aligned_allocator<T>::allocate(size_type n) -> pointer {
    size_type const alignment = std::max(alignof(ptrdiff_t), alignof(T));
    size_type const object_size = sizeof(ptrdiff_t) + sizeof(T)*n;
    size_type const buffer_size = object_size + alignment;

    // block is correctly aligned for `ptrdiff_t` because `std::malloc` returns
    // memory correctly aligned for all built-ins types.
    void* const block = std::malloc(buffer_size);

    if (block == nullptr) { throw std::bad_alloc{}; }

    // find the start of the body by suitably aligning memory,
    // note that we reserve sufficient space for the header beforehand
    void* storage = reinterpret_cast<char*>(block) + sizeof(ptrdiff_t);
    size_t shift = buffer_size;

    void* const body = std::align(alignment, object_size, storage, shift);

    // reverse track to find where the offset field starts
    char* const offset = reinterpret_cast<char*>(body) - sizeof(ptrdiff_t);

    // store the value of the offset (ie, the result of body - block)
    *reinterpret_cast<ptrdiff_t*>(offset) = sizeof(ptrdiff_t) + shift;

    // finally return the start of the body
    return reinterpret_cast<ptrdiff_t>(body);
} // aligned_allocator<T>::allocate

幸运的是，释放例程要简单得多，它只需要读取偏移量并应用它。

template <typename T>
void aligned_allocator<T>::deallocate(pointer p, size_type) {
    // find the offset field
    char const* header = reinterpret_cast<char*>(p) - sizeof(ptrdiff_t);

    // read its value
    ptrdiff_t const offset = *reinterpret_cast<ptrdiff_t*>(header);

    // apply it to find start of block
    void* const block = reinterpret_cast<char*>(p) - offset;

    // finally deallocate
    std::free(block);
} // aligned_allocator<T>::deallocate

其他例程不需要知道内存布局，因此编写它们很简单。

原答案:

template <typename T>
class Block {
public:
    Block(Block const&) = delete;
    Block& operator=(Block const&) = delete;

    explicit Block(size_t n);
    ~Block();

private:
    void* _storage;
    T* _begin;
    T* _end;
}; // class Block

template <typename T>
Block<T>::Block(size_t n) {
    size_t const object_size = n * sizeof(T);
    size_t const buffer_size = object_size + alignof(T);

    _storage = std::malloc(size);

    void* stock = _storage;
    size_t shift = buffer_size;
    std::align(alignof(T), object_size, stock, shift);

    _begin = _end = reinterpret_cast<T*>(stock);
} // Block<T>::Block

template <typename T>
Block<T>::~Block() {
    for (; _end != _begin; --_end) {
        (_end - 1)->~T();
    }

    std::free(_storage);
} // Block<T>::~Block

关于c++ - std::align 和 std::aligned_storage 用于内存块的对齐分配，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17378444/