CKTIS / C++
Odstraněná funkce (`= delete`)
Zakažte konkrétní přetížení nebo kopírování už při překladu, ale zachovejte přesouvání a správné zničení skryté implementace.
Verze: ISO C++23; implementation support may vary
Syntaxe
void f(int) = delete;
// Inside class T:
T(const T&) = delete;
T& operator=(const T&) = delete;V C++23 zápis = delete; výslovně definuje funkci jako odstraněnou a musí být v její první deklaraci. Takovou funkci nelze volat ani získat její adresu. Platí to pro členské funkce i pro funkce v oboru jmenného prostoru. Nejde o výraz jako delete p;, který slouží ke zničení objektu a uvolnění jeho paměti, nikoli k zákazu funkce.
Varianta výslovně odstraněná pomocí = delete se stále účastní výběru přetížení. Při deklaracích void f(double); a void f(int) = delete; volání f(1) vybere přesnou shodu f(int) a je nepřípustné: překladač nepřejde na f(double). Volání f(1.0) vybere f(double). Naproti tomu se při výběru přetížení nepřihlíží k přesouvacímu konstruktoru nebo operátoru přesouvacího přiřazení s výchozí definicí, pokud je definován jako odstraněný.
Widget odstraňuje kopírovací konstruktor a operátor kopírovacího přiřazení. U přesouvacího konstruktoru, operátoru přesouvacího přiřazení a destruktoru zápis = default naopak žádá překladač o vygenerování definic podle pravidel jazyka. Taková funkce může být přesto definována jako odstraněná, pokud není dostupná potřebná operace s některým členem nebo základní třídou.
V idiomu PImpl lze std::unique_ptr<Impl> deklarovat, i když je Impl ještě neúplný typ, ale výchozí deleter vyžaduje úplný typ. To je důležité při destrukci a přesouvacím přiřazení, které může zničit objekt dříve vlastněný cílem. Příklad definuje destruktor i obě přesouvací operace mimo třídu, až po definici Impl. Při rozdělení kódu zůstanou deklarace v hlavičce a tyto definice patří do souboru .cpp.
Příklady
#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';
}
Výsledek
false false true
Kontroly `static_assert` potvrzují, že kopírování je zakázané a přesouvání povolené. `false false true` znamená, že po obou přesunech vlastní `Impl` pouze `c`. Odkomentujte vždy jen jeden z pokusů o kopírování, abyste viděli chybu při překladu.
Související lekce
- C++ · Lekce 11 · Pokročilá · Verze: 3
Zdroje
- 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