存储器用于对齐分配内存块
我试图分配的大小的存储器块size需要被Alignment排列，其中尺寸可以在编译时定义。 我知道如_aligned_alloc ， posix_memalign ， _mm_alloc等例程，但我不想使用它们，因为它们降低了代码的可移植性。
C ++ 11提供了一个例程std::align ，还有一个std::aligned_storage类，我可以从中检索一个POD类型来分配一个将与我的需求对齐的元素。 不过，我的目标是创建一个分配器，它将分配一个size的内存块（而不仅仅是一个元素），它将被对齐。
这可能使用std::align ？ 我问的原因是因为std::align移动指针，使用该指针的类将为分配器提供一个指向移动地址的指针，以取消分配，这将是无效的。 有没有办法以这种方式创建aligned_allocator？
编辑：从OP的澄清后，似乎原来的答案是离题; 为了参考，它保存在这个答案的最后。
实际上，答案很简单：您只需将指针同时保存到存储块和第一项。
实际上，这并不需要有状态的分配器（即使在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 ++ 11解决方案，那么忽略这个答案。
如果没有......我不知道你是否已经知道这一点，但这里有一个选择：
void * aligned_malloc( size_t size, size_t alignement )
{
void * p = malloc( size + --alignement );
void * p1 = (void*)( ( (size_t)p + alignement ) & ~alignement );
((char*)p1)[ -1 ] = (char)((char*)p1 - (char*)p);
return p1;
}
void aligned_free( void * pMem )
{
char * pDelete = (char*)pMem - ((char*)pMem)[ -1 ];
free( pDelete );
}
也许malloc和free不是100％可移植的，但用预处理器指令处理这种情况很容易。