Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

Obrisane funkcije (`= delete`) u C++-u

`= delete` zabranjuje uporabu određene funkcije već pri prevođenju. Tako se može odbiti neželjeno preopterećenje ili spriječiti kopiranje i premještanje objekta koji upravlja memorijskim spremištem.

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

Sintaksa

void f(int);
void f(double) = delete;

struct Pool {
    explicit Pool(int value);
    Pool(double) = delete;
    Pool(const Pool&) = delete;
    Pool& operator=(const Pool&) = delete;
    Pool(Pool&&) = delete;
    Pool& operator=(Pool&&) = delete;
};

Zapis = delete;, dostupan od C++11 i obuhvaćen standardom ISO C++23, već pri prvoj deklaraciji izričito definira funkciju kao obrisanu, bez tijela u vitičastim zagradama. Primjenjuje se na funkcije članice i na funkcije u dosegu imenskog prostora. Poziv obrisane funkcije, čak i implicitan, ili uzimanje njezine adrese pogreška je pri prevođenju, a ne pri izvršavanju.

Izričito obrisana inačica još uvijek sudjeluje u odabiru preopterećenja. Ako bude odabrana, poziv je nevaljan: prevoditelj neće prijeći na inačicu koja slabije odgovara. Za Pool{42.0} konstruktor Pool(double) točno odgovara argumentu, pa pretvorba u int ne spašava poziv. Nasuprot tome, konstruktor premještanja ili operator dodjele premještanjem deklariran s default, a definiran kao obrisan, zanemaruje se pri odabiru preopterećenja.

Pool posjeduje jedno mjesto u memoriji i čuva pokazivač na objekt u vlastitom međuspremniku. Kad bi se kopirala samo vrijednost pokazivača, on bi i dalje pokazivao u međuspremnik izvornog objekta. Zato klasa izričito briše konstruktor kopiranja i operator dodjele kopiranjem te konstruktor premještanja i operator dodjele premještanjem.

Standardni nealocirajući oblik ::new (adresa) T{...} konstruira objekt u postojećoj memoriji dovoljne veličine i odgovarajućeg poravnanja. Izričit poziv destruktora item_->~Item() završava životni vijek objekta bez oslobađanja međuspremnika. Izrazi delete p i delete[] p služe za uništavanje objekata i oslobađanje memorije dobivene odgovarajućim alocirajućim oblikom new. Nemoj ih upotrebljavati za objekt u ovom međuspremniku. Sam = delete ne uništava objekte i ne oslobađa memoriju.

Primjeri

#include <cstddef>
#include <iostream>
#include <new>
#include <type_traits>

class Pool {
    struct Item { int value; };
    alignas(Item) std::byte slot_[sizeof(Item)];
    Item* item_;

public:
    explicit Pool(int value)
        : item_(::new (static_cast<void*>(slot_)) Item{value}) {}
    Pool(double) = delete;
    Pool(const Pool&) = delete;
    Pool& operator=(const Pool&) = delete;
    Pool(Pool&&) = delete;
    Pool& operator=(Pool&&) = delete;

    ~Pool() { item_->~Item(); }
    int value() const noexcept { return item_->value; }
};

static_assert(!std::is_copy_constructible_v<Pool>);
static_assert(!std::is_copy_assignable_v<Pool>);
static_assert(!std::is_move_constructible_v<Pool>);
static_assert(!std::is_move_assignable_v<Pool>);

int main() {
    Pool a{42};
    std::cout << a.value() << '\n';

    // Pool b = a;
    // Pool c{42.0};
}

Rezultat

42

Četiri provjere `static_assert` obuhvaćaju konstrukciju i dodjelu kopiranjem i premještanjem. Program bi trebao ispisati `42`. Ukloni oznaku komentara sa svake od posljednjih dviju deklaracija zasebno: prevođenje bi trebalo završiti pogreškom jer se odabire obrisani konstruktor.

Povezane lekcije

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

Izvori