CKTIS / C++
Funções eliminadas (`= delete`) em C++
`= delete` impede a utilização de uma função específica em tempo de compilação. Permite rejeitar uma sobrecarga indesejada ou impedir a cópia e a movimentação de uma pool proprietária.
Versão: ISO C++23; implementation support may vary
Sintaxe
void f(int);
void f(double) = delete;
struct Pool {
explicit Pool(int value);
Pool(double) = delete;
Pool(const Pool&) = delete;
Pool& operator=(const Pool&) = delete;
Pool(Pool&&) = delete;
Pool& operator=(Pool&&) = delete;
};A sintaxe = delete;, disponível desde C++11 e presente em ISO C++23, define explicitamente uma função como eliminada logo na sua primeira declaração, sem um corpo entre chavetas. Aplica-se a funções-membro e a funções no âmbito de um espaço de nomes. Chamar uma função eliminada, mesmo implicitamente, ou obter o seu endereço é um erro de compilação, não de execução.
Uma sobrecarga explicitamente eliminada continua a participar na resolução de sobrecargas. Se for selecionada, a chamada é inválida: o compilador não recorre a uma sobrecarga menos adequada. Em Pool{42.0}, Pool(double) é uma correspondência exata, pelo que a conversão para int não torna a chamada válida. Em contrapartida, a resolução ignora um construtor ou operador de atribuição por movimento declarado default que seja definido como eliminado.
Pool é proprietária de um único espaço de armazenamento e guarda um apontador para o objeto no seu próprio buffer. Copiar apenas o valor do apontador faria com que continuasse a apontar para o buffer da pool de origem. Por isso, a classe elimina explicitamente tanto o construtor e o operador de atribuição por cópia como o construtor e o operador de atribuição por movimento.
A forma padrão não alocadora ::new (endereço) T{...} constrói um objeto em memória já disponível, com tamanho suficiente e alinhamento adequado. A chamada explícita ao destrutor item_->~Item() termina o tempo de vida do objeto sem libertar o buffer. As expressões delete p e delete[] p servem para destruir objetos e libertar a memória obtida com a forma correspondente de new que aloca memória. Não as uses para o objeto neste buffer. = delete não destrói objetos nem liberta memória.
Exemplos
#include <cstddef>
#include <iostream>
#include <new>
#include <type_traits>
class Pool {
struct Item { int value; };
alignas(Item) std::byte slot_[sizeof(Item)];
Item* item_;
public:
explicit Pool(int value)
: item_(::new (static_cast<void*>(slot_)) Item{value}) {}
Pool(double) = delete;
Pool(const Pool&) = delete;
Pool& operator=(const Pool&) = delete;
Pool(Pool&&) = delete;
Pool& operator=(Pool&&) = delete;
~Pool() { item_->~Item(); }
int value() const noexcept { return item_->value; }
};
static_assert(!std::is_copy_constructible_v<Pool>);
static_assert(!std::is_copy_assignable_v<Pool>);
static_assert(!std::is_move_constructible_v<Pool>);
static_assert(!std::is_move_assignable_v<Pool>);
int main() {
Pool a{42};
std::cout << a.value() << '\n';
// Pool b = a;
// Pool c{42.0};
}Resultado
42
As quatro verificações `static_assert` abrangem a construção e a atribuição por cópia e por movimento. O programa deverá escrever `42`. Retira o comentário de cada uma das duas últimas declarações, uma de cada vez: a compilação deverá falhar porque é selecionado um construtor eliminado.
Lições relacionadas
- C++ · Lição 19 · Avançado · Versão: 3
Fontes
- Working Draft, Standard for Programming Language C++ (N4950, C++23)
- Deleted definitions [dcl.fct.def.delete]
- Copy/move constructors [class.copy.ctor]
- Copy/move assignment operator [class.copy.assign]
- Non-allocating forms [new.delete.placement]
- Destructors [class.dtor]
- Object lifetime [basic.life]
- Delete [expr.delete]