CKTIS / C++
std::align_val_t — type de l’argument d’alignement mémoire
std::align_val_t, défini dans <new>, transmet un alignement requis aux surcharges d’allocation et de désallocation. Ce type d’énumération distinct permet de différencier un argument d’alignement d’un argument de taille mémoire.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <new>
// Declaration in namespace std:
enum class align_val_t : size_t {};
// Explicit aligned allocation and matching deallocation:
void* p = ::operator new(sizeof(T), std::align_val_t{alignof(T)});
::operator delete(p, std::align_val_t{alignof(T)});std::align_val_t est une énumération à portée déclarée dans <new>, sans énumérateur nommé et dont le type sous-jacent est std::size_t. Une valeur telle que std::align_val_t{alignof(T)} indique l’alignement requis en octets, et non la taille de l’allocation. Son type distinct différencie les surcharges qui acceptent un alignement de celles qui acceptent une taille.
Pour new T, lorsque l’alignement du type dépasse __STDCPP_DEFAULT_NEW_ALIGNMENT__, la sélection de la fonction d’allocation considère d’abord un argument d’alignement de type std::align_val_t. Les surcharges propres à une classe peuvent influer sur la sélection ; le code ordinaire n’a pas besoin de transmettre cet argument manuellement.
L’appel direct à ::operator new(size, alignment) alloue du stockage, mais n’appelle pas de constructeur pour T. Libérez ce stockage avec le ::operator delete(ptr, alignment) correspondant, en transmettant la même valeur d’alignement. Ne mélangez pas ces fonctions avec free, une désallocation ordinaire sans alignement ou les formes pour tableaux. En C++23, libérer du stockage alloué dynamiquement peut mettre fin à la durée de vie d’un objet sans appeler son destructeur, même si celui-ci n’est pas trivial. La libération du stockage n’appelle pas implicitement le destructeur : ses opérations de nettoyage ne sont donc pas exécutées et ses autres effets de bord ne se produisent pas.
La conversion en std::align_val_t ne vérifie pas l’alignement : transmettre une valeur invalide aux fonctions d’allocation ou de désallocation entraîne un comportement indéfini. Utilisez alignof(T) plutôt que de deviner les valeurs prises en charge. Dans l’exemple, placement new initialise un int, le résultat est copié et le stockage est libéré avant l’affichage. int ne nécessite aucun appel explicite au destructeur.
Exemples
#include <iostream>
#include <new>
int main() {
constexpr auto alignment = std::align_val_t{alignof(int)};
void* storage = ::operator new(sizeof(int), alignment);
int* value = ::new (storage) int{42};
const int result = *value;
::operator delete(storage, alignment);
std::cout << result << '\n';
}
Résultat
42
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.