Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

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