CKTIS / C++
Tempo de vida dos objetos e aliasing estrito
A memória pode continuar disponível após a destruição de um objeto. O tempo de vida determina quando o objeto existe; o aliasing estrito determina através de que tipos se pode aceder ao seu valor.
Versão: ISO C++23; implementation support may vary
Sintaxe
alignas(T) std::byte storage[sizeof(T)];
T* p = ::new (static_cast<void*>(storage)) T{args...};
p->~T();
// Schematic: T is a class type; args... denotes its initializer arguments.
// Headers: <cstddef> for std::byte; <new> for placement new and std::launder.
// When its preconditions are met: T* q = std::launder(candidate);Em ISO C++23, importa distinguir o armazenamento, o tempo de vida do objeto e o tipo da expressão usada para lhe aceder. Em geral, o tempo de vida começa quando existe armazenamento com tamanho e alinhamento adequados e a inicialização está concluída. Para um objeto de classe, acaba quando começa a chamada ao destrutor; também pode acabar se a memória for libertada ou reutilizada por outro objeto que não esteja nele aninhado. A construção e a destruição têm regras próprias.
::new (static_cast<void*>(storage)) T{args...} seleciona a forma global normalizada de placement new que não aloca memória. A função operator new devolve o endereço fornecido; a expressão new constrói aí um T e devolve um T*. p->~T() chama o destrutor sem libertar a memória da arena ou do buffer. Não uses delete p num objeto construído num buffer deste modo nem o destruas duas vezes.
Depois da destruição, a memória pode continuar disponível, mas não deves ler nem escrever o valor do objeto fora do seu tempo de vida. Ao construir um substituto, usa o ponteiro devolvido pela expressão new. Se a substituição for transparente, os ponteiros, as referências e o nome anteriores passam automaticamente a designar o novo objeto quando o seu tempo de vida começa. Por exemplo, isto acontece quando um objeto completo não const é substituído por um objeto completo do mesmo tipo exatamente no mesmo espaço.
std::launder(p) pode obter um ponteiro para o novo objeto quando as referências anteriores não passam a designá-lo automaticamente. Já tem de existir nesse endereço um objeto vivo de tipo semelhante no sentido da norma, e todos os bytes alcançáveis através do resultado têm de ser alcançáveis através de p. std::launder não inicia o tempo de vida, não corrige o alinhamento nem contorna as regras de aliasing.
O aliasing estrito diz respeito ao tipo da glvalue, a expressão que designa o objeto. Aceder ao valor armazenado através de um tipo não permitido causa comportamento indefinido. São permitidos um tipo semelhante ao tipo dinâmico do objeto, o tipo correspondente com ou sem sinal e char, unsigned char ou std::byte para aceder à sua representação. signed char não é uma exceção geral para o acesso aos bytes. Um reinterpret_cast por si só não torna o acesso válido nem cria um objeto.
Exemplos
#include <cstddef>
#include <cstdio>
#include <new>
struct Item {
int value;
~Item() { std::puts("destroy"); }
};
int main() {
alignas(Item) std::byte storage[sizeof(Item)];
void* slot = storage;
Item* p = ::new (slot) Item{7};
const unsigned int& alias = reinterpret_cast<const unsigned int&>(p->value);
std::printf("%u\n", alias);
p->~Item();
Item* q = ::new (slot) Item{9};
std::printf("%d\n", q->value);
q->~Item();
}Resultado
7 destroy 9 destroy
O programa lê o membro `int` vivo através de uma referência ao tipo correspondente `unsigned int`. Depois de destruir o primeiro `Item`, constrói um segundo no mesmo buffer e usa o novo ponteiro. Cada destrutor escreve `destroy`; nenhum liberta o buffer.
Lições relacionadas
- C++ · Lição 16 · Avançado · Versão: 3
Fontes
- N4950: Working Draft, Standard for Programming Language C++ (C++23 draft)
- Lifetime [basic.life] (living draft)
- Value category [basic.lval] (living draft)
- Non-allocating forms [new.delete.placement] (living draft)
- Destructors [class.dtor] (living draft)
- Pointer optimization barrier [ptr.launder] (living draft)