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

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