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

CKTIS / C++

Placement new: construção em memória existente

Constrói um objeto num espaço preparado, gere o seu tempo de vida separadamente da memória e impede a cópia e a movimentação do objeto proprietário.

Versão: ISO C++23; implementation support may vary

Sintaxe

#include <new>

// Assumes overload resolution selects the standard non-allocating placement overload.
T* p = ::new (static_cast<void*>(storage)) T(args...);  // Construct one T in existing storage.
p->~T();                                              // Destroy that T without freeing the storage.

// Inside the owning class, disable copying and moving:
Owner(const Owner&) = delete;
Owner& operator=(const Owner&) = delete;
Owner(Owner&&) = delete;
Owner& operator=(Owner&&) = delete;

Em C++23, ::new (static_cast<void*>(storage)) T(args...) constrói um T no endereço fornecido e devolve um T* se for selecionada a sobrecarga padrão operator new(std::size_t, void*) de <new>, que não aloca memória. Essa sobrecarga global limita-se a devolver o endereço. O prefixo :: evita a pesquisa no âmbito da classe, mas a conversão para void* não garante a seleção da sobrecarga padrão. Se alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, a resolução de sobrecargas inclui primeiro um argumento adicional do tipo std::align_val_t, pelo que pode ser selecionada, em alternativa, uma sobrecarga global de placement que aceite o argumento de alinhamento. Se não for encontrada uma função de alocação correspondente, a resolução é repetida sem o argumento de alinhamento. A expressão habitual new T(args...), na forma que aloca, obtém memória e inicializa o objeto. Outras sobrecargas de placement podem alocar memória.

Fornece um endereço válido e não nulo, pelo menos sizeof(T) bytes disponíveis e um alinhamento que respeite alignof(T). O exemplo usa alignas(Item) para o alinhamento. O tempo de vida do objeto construído começa após a inicialização bem-sucedida. Se o construtor lançar uma exceção, o operator delete(void*, void*) de placement padrão correspondente não liberta memória. Marca o espaço como ocupado só depois de a construção ter sucesso.

Guarda o T* devolvido pela expressão new. Uma conversão de tipo, por si só, não constrói um objeto, e a coincidência de endereços não permite o acesso através de um tipo incompatível (regras de aliasing estrito). std::launder pode obter um ponteiro para um objeto de tipo semelhante já vivo nesse endereço, se a condição de alcance dos bytes for cumprida. Não inicia o tempo de vida nem corrige o alinhamento. Aqui não é necessário.

A chamada explícita ao destrutor p->~T() destrói o objeto sem libertar a memória da arena ou do tampão. Neste padrão, destrói cada objeto construído com sucesso exatamente uma vez, antes de reutilizares o espaço ou de terminar o tempo de vida do tampão. Não uses delete p num objeto deste tampão: uma expressão delete associada a uma expressão new de alocação adequada normalmente destrói o objeto e liberta a memória.

= delete define uma função eliminada; não é uma expressão delete. A função continua a participar na resolução de sobrecargas, mas uma chamada que a selecione é malformada. Slot elimina os construtores de cópia e de movimentação e os dois operadores de atribuição correspondentes. A cópia predefinida membro a membro copiaria o ponteiro para o tampão de origem sem construir um Item no tampão de destino.

Exemplos

#include <cstddef>
#include <cstdio>
#include <new>

struct Item {
    int value;
    explicit Item(int n) : value(n) {}
    ~Item() { std::puts("destroyed"); }
};

class Slot {
    alignas(Item) std::byte storage_[sizeof(Item)];
    Item* item_ = nullptr;

public:
    Slot() = default;
    ~Slot() { reset(); }

    Slot(const Slot&) = delete;
    Slot& operator=(const Slot&) = delete;
    Slot(Slot&&) = delete;
    Slot& operator=(Slot&&) = delete;

    Item& emplace(int n) {
        reset();
        item_ = ::new (static_cast<void*>(storage_)) Item(n);
        return *item_;
    }

    void reset() noexcept {
        if (item_) {
            item_->~Item();
            item_ = nullptr;
        }
    }
};

int main() {
    Slot slot;
    std::printf("%d\n", slot.emplace(7).value);
    std::printf("%d\n", slot.emplace(9).value);
}

Resultado

7
destroyed
9
destroyed

A segunda chamada a `emplace` destrói o `Item` que contém `7` antes de construir o que contém `9` no mesmo tampão. O destrutor de `Slot` destrói o segundo objeto.

Lições relacionadas

  • C++ · Lição 16 · Avançado · Versão: 3
  • C++ · Lição 19 · Avançado · Versão: 3

Fontes