Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C++

Izbrisana funkcija (`= delete`)

Onemogoči določeno preobremenitev ali kopiranje že med prevajanjem, pri tem pa ohrani premikanje in pravilno uničenje skrite implementacije.

Različica: ISO C++23; implementation support may vary

Sintaksa

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

V C++23 zapis = delete; izrecno definira funkcijo kot izbrisano in mora biti naveden že ob njeni prvi deklaraciji. Take funkcije ni dovoljeno klicati niti vzeti njenega naslova. To velja tako za članske funkcije kot za funkcije v imenskem prostoru. To ni izraz, kot je delete p;, ki je namenjen uničenju objekta in sprostitvi pomnilnika, ne onemogočanju funkcije.

Preobremenitev, izrecno izbrisana z = delete, še vedno sodeluje pri razreševanju preobremenitev. Pri void f(double); in void f(int) = delete; klic f(1) izbere natančno ujemanje f(int) in je neveljaven: prevajalnik ne preide na f(double). Klic f(1.0) izbere f(double). Nasprotno pa se privzeti premikalni konstruktor ali operator premikalnega prirejanja pri razreševanju preobremenitev ne upošteva, če je definiran kot izbrisan.

Widget izbriše kopirni konstruktor in operator kopirnega prirejanja. Pri premikalnem konstruktorju, operatorju premikalnega prirejanja in destruktorju pa z = default od prevajalnika zahteva, da jih ustvari po pravilih jezika. Tako zahtevana funkcija je kljub temu lahko definirana kot izbrisana, če zahtevana operacija nad članom ali osnovnim razredom ni na voljo.

Pri idiomu PImpl je std::unique_ptr<Impl> mogoče deklarirati, ko je Impl še nepopoln, vendar privzeti brisalnik potrebuje popoln tip. To je pomembno pri uničenju in pri premikalnem prirejanju, ki lahko uniči objekt, ki ga je cilj prej imel v lasti. Primer definira destruktor in obe premikalni operaciji zunaj razreda, za definicijo Impl. Če kodo razdelimo, deklaracije ostanejo v glavi, te definicije pa sodijo v datoteko .cpp.

Primeri

#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

Preverjanja `static_assert` potrdijo, da je kopiranje onemogočeno, premikanje pa dovoljeno. `false false true` pomeni, da ima po obeh premikih samo `c` v lasti `Impl`. Odstrani komentar pri enem poskusu kopiranja naenkrat, da vidiš napako pri prevajanju.

Povezane lekcije

  • C++ · Lekcija 11 · Napredna · Različica: 3

Viri