Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::align_val_t — tipo do argumento de alinhamento da memória

std::align_val_t, de <new>, transporta um alinhamento necessário para sobrecargas de alocação e desalocação. É um tipo de enumeração distinto que permite distinguir um argumento de alinhamento de um argumento relativo ao tamanho do armazenamento.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#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 é uma enumeração com âmbito, declarada em <new>, sem enumeradores com nome e com tipo subjacente std::size_t. Um valor como std::align_val_t{alignof(T)} indica o alinhamento necessário em bytes, não o tamanho da alocação. O seu tipo distinto diferencia as sobrecargas que aceitam um alinhamento das que aceitam um tamanho.

Para new T, quando o alinhamento do tipo excede __STDCPP_DEFAULT_NEW_ALIGNMENT__, a seleção da função de alocação considera primeiro um argumento de alinhamento do tipo std::align_val_t. Sobrecargas específicas de uma classe podem influenciar a seleção; o código habitual não precisa de passar este argumento manualmente.

Uma chamada direta a ::operator new(size, alignment) aloca armazenamento, mas não invoca um construtor para T. Liberta esse armazenamento com o ::operator delete(ptr, alignment) correspondente, passando o mesmo valor de alinhamento. Não misture estas funções com free, a desalocação normal sem alinhamento ou as formas para arrays. Em C++23, libertar armazenamento alocado dinamicamente pode pôr fim ao tempo de vida de um objeto sem invocar o seu destrutor, mesmo que este não seja trivial. A libertação do armazenamento não invoca implicitamente o destrutor, pelo que as suas operações de limpeza não são executadas e os seus restantes efeitos secundários não ocorrem.

A conversão para std::align_val_t não valida o alinhamento: passar um valor inválido às funções de alocação ou desalocação causa comportamento indefinido. Use alignof(T) em vez de tentar adivinhar os valores suportados. No exemplo, placement new inicializa um int, o resultado é copiado e o armazenamento é libertado antes da impressão. int não precisa de uma chamada explícita ao destrutor.

Exemplos

#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';
}

Resultado

42

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes