Allocation de mémoire alignée dynamique en C++11

Question

posix_memalign et _aligned_malloc sous Windows permettent d'allouer dynamiquement un bloc de mémoire aligné. Y a-t-il quelque chose de similaire en C++11 ? Pour autant que je sache, le mot-clé alignas ne fonctionne qu'avec des objets alloués statiquement.

Answer 1

Vous pouvez utiliser posix_memalign/_aligned_malloc pour allouer un morceau de mémoire, puis utiliser la syntaxe spéciale 'new' de l'opérateur pour initialiser un objet dans cette région de mémoire. Quelque chose comme ceci :

// 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);

Answer 2

Jetez un œil à std::aligned_storage l'opérateur alignas(). Ils font partie de C++11, et semblent être exactement ce que vous cherchez.

Answer 3

C++03 et C++0x ont operator new.

new T ou new T[] garantit de renvoyer une mémoire correctement alignée pour un objet de type T.

new char[], new signed char[] et new unsigned char[] garantissent de renvoyer la mémoire correctement alignée pour tout objet, afin que vous puissiez utiliser le placement nouveau sur elle.

Answer 4

Pour la mémoire alignée allouée sur le tas, j'utilise l'implémentation align() dehttp://code.google.com/p/c-plus/source/browse/src/util.h #57, car mon gcc4.8 ne semble pas le prendre en charge. Voici un exemple de code :

typedef float TItem;
static const int SIZE = 100;
static const int ALIGNMENT = 16;

// allocate heap storage larger then SIZE
TItem* storage = new TItem[SIZE + (ALIGNMENT / sizeof(TItem))];
void* storage_ptr = (void*)storage;
size_t storage_size = sizeof(TItem) * (SIZE + 1);
// aligned_array should be properly aligned
TItem* aligned_array = (TItem*) align(MEM_ALIGNMENT, sizeof(TItem) * SIZE, storage_ptr, storage_size);
if (!aligned_array) { throw std::bad_alloc(); }