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
- WG21 N4950 — Working Draft, Standard for Programming Language C++ (C++23 baseline)
- New expressions [expr.new] — C++ working draft
- Non-allocating forms [new.delete.placement] — C++ working draft
- Lifetime [basic.life] — C++ working draft
- Value category and type accessibility [basic.lval] — C++ working draft
- Pointer optimization barrier [ptr.launder] — C++ working draft
- Destructors [class.dtor] — C++ working draft
- Delete expressions [expr.delete] — C++ working draft
- Deleted definitions [dcl.fct.def.delete] — C++ working draft