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

CKTIS / C++

Memória: propriedade, cópias e tempo de vida dos objetos

Distingue o espaço de memória, o objeto que o ocupa e a responsabilidade pelo recurso. Conhece a duração de armazenamento automática e dinâmica, a semântica de cópia, o placement new, a destruição explícita e as restrições de aliasing estrito.

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

Sintaxe

T copy = original; T* alias = &original; T* p = ::new (static_cast<void*>(storage)) T{args}; p->~T();

O armazenamento dá espaço aos dados; o tempo de vida diz respeito ao objeto que o ocupa. Em geral, começa quando há espaço suficiente, bem alinhado, e a inicialização termina. Num objeto de classe, acaba no início da chamada ao destrutor; libertar ou reutilizar o espaço também pode terminá-lo. Um endereço válido não basta para aceder ao objeto.

Duração de armazenamento. Define a disponibilidade do espaço. Uma variável local comum tem duração automática, até à saída do bloco. Objetos criados por new com alocação têm duração dinâmica e podem sobreviver ao bloco. Um std::unique_ptr local pode ter duração automática e o seu objeto, dinâmica. Pilha e heap são modelos típicos de implementação, não definições.

Propriedade. É a responsabilidade de libertar o recurso. Usa RAII: o destrutor do proprietário trata da limpeza. std::unique_ptr pode ser movido, mas não copiado. Copiar um ponteiro simples copia o endereço, não o objeto nem o dever de o eliminar. Por omissão, uma classe copia os membros; um membro ponteiro continua a apontar para o mesmo objeto. A cópia pode não ser profunda; dois proprietários independentes do mesmo endereço arriscam uma eliminação dupla.

Placement new. Em ::new (storage) T{args}, o :: inicial restringe a procura da função de alocação ao âmbito global, mas não obriga a escolher a sobrecarga padrão que recebe um void*. Uma sobrecarga global que corresponda melhor ao tipo de storage pode alocar memória. O exemplo usa a forma ::new (static_cast<void*>(storage)) T{args} com o tipo Item: é selecionada a sobrecarga padrão que não aloca memória e o objeto é construído no espaço fornecido. A conversão para void*, por si só, não garante essa escolha para qualquer T. Se T exigir um alinhamento superior ao alinhamento por omissão de new (alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__), a primeira tentativa de resolução de sobrecargas inclui um argumento do tipo std::align_val_t antes do argumento de placement. Uma sobrecarga global viável operator new(std::size_t, std::align_val_t, void*) pode então ser selecionada em vez da sobrecarga padrão que não aloca memória. O espaço tem de ser suficiente e estar corretamente alinhado. p->~T() destrói explicitamente o objeto sem libertar o espaço. Não uses delete num objeto colocado num buffer local. Não destruas um objeto duas vezes: após destruir explicitamente uma variável local comum com destrutor não trivial, reconstrói corretamente um objeto do tipo original antes da destruição automática.

Aliasing estrito. Limita os tipos usados para ler ou alterar o valor do objeto. reinterpret_cast não permite o acesso por um tipo incompatível. char, unsigned char e std::byte permitem aceder à representação, mas não substituem as regras de tempo de vida. O exemplo usa um subconjunto compatível com C++23; o URL da norma aponta para o rascunho em evolução, não para a edição fixa de C++23.

Identificadores de referência abrangidos por esta entrada: Object lifetime, placement new, explicit destruction and strict aliasing, Automatic and dynamic storage duration.

Exemplos

#include <cstddef>
#include <iostream>
#include <memory>
#include <new>

struct Item {
    int value;
    ~Item() {}
};

int main() {
    Item original{7};
    Item copy = original;
    Item* alias = &original;
    alias->value = 9;

    auto owner = std::make_unique<Item>();
    owner->value = 11;

    alignas(Item) std::byte storage[sizeof(Item)];
    Item* placed = ::new (static_cast<void*>(storage)) Item{13};

    std::cout << original.value << ' ' << copy.value << ' '
              << owner->value << ' ' << placed->value << '\n';

    placed->~Item();
}

Resultado

9 7 11 13

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