Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Funkcja usunięta (`= delete`)

Zablokuj wywołanie wybranego przeciążenia lub kopiowanie obiektu, zachowując przenoszenie i poprawne niszczenie obiektu z ukrytą implementacją.

Wersja: ISO C++23; implementation support may vary

Składnia

void f(int) = delete;
// Inside class T:
T(const T&) = delete;
T& operator=(const T&) = delete;

W C++23 zapis = delete; jawnie definiuje funkcję jako usuniętą i musi pojawić się już w jej pierwszej deklaracji. Takiej funkcji nie można wywołać ani pobrać jej adresu. Można w ten sposób oznaczyć zarówno funkcję składową, jak i funkcję w przestrzeni nazw. Nie jest to wyrażenie delete p;, które służy do niszczenia obiektu i zwalniania pamięci, a nie do blokowania funkcji.

Przeciążenie jawnie usunięte przez = delete nadal bierze udział w rozstrzyganiu przeciążeń. Jeśli istnieją void f(double); i void f(int) = delete;, wywołanie f(1) wybiera dokładne dopasowanie f(int) i jest niepoprawne: kompilator nie wraca do f(double). Wywołanie f(1.0) wybiera f(double). Natomiast domyślny konstruktor przenoszący lub domyślny operator przypisania przenoszącego, jeśli zostanie zdefiniowany jako usunięty, jest pomijany przy rozstrzyganiu przeciążeń.

Widget usuwa konstruktor kopiujący i operator przypisania kopiującego. Dla konstruktora przenoszącego, operatora przypisania przenoszącego i destruktora używa natomiast = default, prosząc kompilator o wygenerowanie ich zgodnie z regułami języka. Funkcja zdefiniowana przez = default może mimo to okazać się usunięta, jeśli wymagane operacje na składowych lub klasach bazowych są niedostępne.

W idiomie PImpl std::unique_ptr<Impl> można zadeklarować, gdy Impl jest jeszcze typem niekompletnym, ale domyślny deleter wymaga typu kompletnego. Ma to znaczenie w przypadku destruktora oraz przypisania przenoszącego, które może zniszczyć obiekt dotychczas posiadany przez cel przypisania. Przykład definiuje destruktor i obie operacje przenoszenia poza klasą, po definicji Impl. Przy rozdzieleniu kodu nagłówek zachowuje deklaracje, a te definicje trafiają do pliku .cpp.

Przykłady

#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';
}

Wynik

false false true

`static_assert` sprawdza, że kopiowanie jest zabronione, a przenoszenie dozwolone. Wynik `false false true` oznacza, że po obu przeniesieniach tylko `c` posiada `Impl`. Odkomentuj osobno każdą próbę kopiowania, aby uzyskać błąd kompilacji.

Powiązane lekcje

  • C++ · Lekcja 11 · Zaawansowany · Wersja: 3

Źródła