Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

Izbrisana funkcija (`= delete`)

Zabranite određeno preopterećenje ili kopiranje pri prevođenju, uz zadržavanje premještanja i ispravnog uništavanja skrivene implementacije.

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

Sintaksa

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

U C++23 zapis = delete; izričito definira funkciju kao izbrisanu i mora stajati u njezinoj prvoj deklaraciji. Takvu funkciju nije dopušteno pozvati ni uzeti njezinu adresu. To vrijedi za funkcije članice i za funkcije u dosegu imenskog prostora. To nije izraz poput delete p;, koji služi za uništavanje objekta i oslobađanje memorije, a ne za onemogućavanje funkcije.

Preopterećenje izričito izbrisano s pomoću = delete i dalje sudjeluje u razrješavanju preopterećenja. Uz void f(double); i void f(int) = delete;, poziv f(1) odabire točno podudaranje f(int) i neispravan je: prevoditelj ne poseže za f(double). Poziv f(1.0) odabire f(double). Nasuprot tome, konstruktor premještanja ili operator pridruživanja premještanjem sa zadanom definicijom ne uzima se u obzir pri razrješavanju preopterećenja ako je definiran kao izbrisan.

Widget briše konstruktor kopiranja i operator pridruživanja kopiranjem. Za konstruktor premještanja, operator pridruživanja premještanjem i destruktor koristi = default, čime traži od prevoditelja da ih generira prema pravilima jezika. Tako zatražena funkcija ipak može biti definirana kao izbrisana ako potrebna operacija nad članom ili osnovnom klasom nije dostupna.

U idiomu PImpl std::unique_ptr<Impl> može se deklarirati dok je Impl nepotpun tip, ali zadani brisač zahtijeva potpun tip. To je važno pri uništavanju i pri pridruživanju premještanjem, koje može uništiti objekt koji je odredište prethodno posjedovalo. Primjer definira destruktor i obje operacije premještanja izvan klase, nakon definicije Impl. Ako se kôd razdvoji, deklaracije ostaju u zaglavlju, a te definicije idu u datoteku .cpp.

Primjeri

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

Rezultat

false false true

Provjere `static_assert` potvrđuju da je kopiranje zabranjeno, a premještanje dopušteno. `false false true` znači da nakon oba premještanja samo `c` posjeduje `Impl`. Uklonite oznaku komentara sa svakog pokušaja kopiranja zasebno da biste vidjeli pogrešku pri prevođenju.

Povezane lekcije

  • C++ · Lekcija 11 · Napredno · Verzija: 3

Izvori