Dynamic aligned memory allocation in C++11

Solution 1:

It depends on what alignment you require. For anything <= to alignof(std::max_align_t), new works as per n3242 3.7.4.1/2:

The pointer returned shall be suitably aligned so that it can be converted to a pointer of any complete object type with a fundamental alignment requirement

std::max_align_t is a complete object type with the strictest fundamental alignment.

Note that allocation of arrays of char or unsigned char but not signed char have a different rule in 5.3.4/10:

For arrays of char and unsigned char, the difference between the result of the new-expression and the address returned by the allocation function shall be an integral multiple of the strictest fundamental alignment requirement (3.11) of any object type whose size is no greater than the size of the array being created.

So new char[1]; can have an alignment of 1.

As for allocating memory with an alignment greater than alignof(std::max_align_t), C++11 provides no direct way to do this. The only reliable way is to allocate at least size + alignment bytes and use std::align to get a correctly aligned location in this buffer.

This can waste a lot of memory, so if you need a lot of these, you could create an allocator that allocates a chunk large enough for all of them and use std::align on that. Your overhead is then amortized across all of the allocations.

Your other option is to wait for http://open-std.org/JTC1/SC22/WG21/docs/papers/2012/n3396.htm to make it into the standard.

Personally I would just write an abstraction layer over the OS provided APIs for allocating aligned memory.

Solution 2:

You can use posix_memalign/_aligned_malloc to allocate a piece of memory and then using the special 'new' operator syntax to initialize an object in that memory region. Something like this:

// Allocate raw memory for a Foo object.
void *mem;
size_t alignment = 0x1000;
size_t size = ?;
posix_memalign(&mem, alignment, size);
// Call the constructor on the allocated memory.
Foo *foo = new (mem) Foo(...);

// Now you have a useable object.
foo->some_method();

// Call destructor without freeing object memory.
foo->~Foo();
// Free raw memory.
free(foo);

Solution 3:

Take a look at std::aligned_storage and the alignas() operator. They're part of C++11, and seem to be exactly what you're looking for.

Solution 4:

C++03 and C++0x have operator new.

new T or new T[] guarantees to return properly aligned memory for object of type T.

new char[], new signed char[] and new unsigned char[] guarantee to return memory properly aligned for any object, so that you can use placement new on it.