CKTIS / C++
Função eliminada (`= delete`)
Rejeita uma sobrecarga específica ou impede a cópia em tempo de compilação, mantendo a possibilidade de mover e destruir corretamente a implementação oculta.
Versão: ISO C++23; implementation support may vary
Sintaxe
void f(int) = delete;
// Inside class T:
T(const T&) = delete;
T& operator=(const T&) = delete;Em C++23, = delete; define explicitamente uma função como eliminada e tem de constar da sua primeira declaração. Não é possível chamar essa função nem obter o seu endereço. Isto aplica-se tanto a funções-membro como a funções no âmbito de um espaço de nomes. Não é uma expressão como delete p;, que serve para destruir um objeto e libertar a respetiva memória, não para impedir o uso de uma função.
Uma sobrecarga eliminada explicitamente com = delete continua a participar na resolução de sobrecargas. Com void f(double); e void f(int) = delete;, f(1) seleciona a correspondência exata f(int) e é inválida: o compilador não recorre a f(double). A chamada f(1.0) seleciona f(double). Em contrapartida, um construtor de movimento ou um operador de atribuição por movimento especificado como predefinido é ignorado na resolução de sobrecargas se for definido como eliminado.
Widget elimina o construtor de cópia e o operador de atribuição por cópia. Para o construtor de movimento, o operador de atribuição por movimento e o destrutor, usa = default para pedir ao compilador que os gere segundo as regras da linguagem. Uma função assim especificada pode ainda ser definida como eliminada se uma operação necessária num membro ou numa classe base não estiver disponível.
No idioma PImpl, std::unique_ptr<Impl> pode ser declarado enquanto Impl estiver incompleto, mas o eliminador predefinido exige um tipo completo. Isto é importante para a destruição e para a atribuição por movimento, que pode destruir o objeto anteriormente detido pelo destino. O exemplo define o destrutor e ambas as operações de movimento fora da classe, depois da definição de Impl. Ao separar o código, as declarações ficam no cabeçalho e estas definições vão para o ficheiro .cpp.
Exemplos
#include <iostream>
#include <memory>
#include <type_traits>
#include <utility>
class Widget {
public:
Widget();
~Widget();
Widget(const Widget&) = delete;
Widget& operator=(const Widget&) = delete;
Widget(Widget&&) noexcept;
Widget& operator=(Widget&&) noexcept;
bool has_impl() const noexcept { return static_cast<bool>(impl_); }
private:
struct Impl;
std::unique_ptr<Impl> impl_;
};
struct Widget::Impl {};
Widget::Widget() : impl_(std::make_unique<Impl>()) {}
Widget::~Widget() = default;
Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;
static_assert(!std::is_copy_constructible_v<Widget>);
static_assert(!std::is_copy_assignable_v<Widget>);
static_assert(std::is_move_constructible_v<Widget>);
static_assert(std::is_move_assignable_v<Widget>);
int main() {
Widget a;
// Widget copy(a);
Widget b(std::move(a));
Widget c;
// c = b;
c = std::move(b);
std::cout << std::boolalpha << a.has_impl() << ' '
<< b.has_impl() << ' ' << c.has_impl() << '\n';
}
Resultado
false false true
As verificações `static_assert` confirmam que a cópia é proibida e o movimento é permitido. `false false true` significa que apenas `c` detém um `Impl` após os dois movimentos. Retira o comentário a cada tentativa de cópia, uma de cada vez, para veres um erro de compilação.
Lições relacionadas
- C++ · Lição 11 · Avançado · Versão: 3
Fontes
- Deleted definitions [dcl.fct.def.delete]
- Explicitly-defaulted functions [dcl.fct.def.default]
- Delete [expr.delete]
- Default deleter for single objects [unique.ptr.dltr.dflt]
- unique_ptr constructors [unique.ptr.single.ctor]
- unique_ptr destructor [unique.ptr.single.dtor]
- unique_ptr assignment [unique.ptr.single.asgn]
- C++23 working draft N4950