Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

Špeciálne členské funkcie s `= default` v C++

V C++23 zápis `= default` žiada prekladač o štandardnú definíciu špeciálnej členskej funkcie. Pri Pimpl záleží na umiestnení definície; podpora C++23 sa môže líšiť podľa implementácie.

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

Syntax

struct S {
    S() = default;
    S(const S&) = default;
    S(S&&) = default;
    S& operator=(const S&) = default;
    S& operator=(S&&) = default;
    ~S();
};

S::~S() = default;

Zápis = default žiada prekladač, aby podľa pravidiel jazyka definoval predvolený konštruktor, kopírovací či presúvací konštruktor, operátor kopírovacieho či presúvacieho priradenia alebo deštruktor. Nejde o prázdne telo {}: vygenerovaná funkcia použije pravidlá príslušnej operácie na podobjekty základných tried a nestatické dátové členy.

Ak je = default už v prvej deklarácii, funkcia je deklarovaná používateľom, ale nie je user-provided v zmysle normy. Môže byť triviálna, ak spĺňa ostatné podmienky, alebo môže byť definovaná ako odstránená, ak požadovaná operácia s podobjektom nie je dostupná. Ak je = default až v neskoršej definícii, funkcia je user-provided a nie je triviálna. Ak by vygenerovaná definícia musela byť odstránená, program nie je správne utvorený.

= delete má iný význam: odstránená funkcia sa stále zúčastňuje na výbere preťaženia, ale jej výber je chyba. Nejde o výraz delete p a neuvoľňuje pamäť. Deštruktor deklarovaný používateľom, aj s = default, bráni implicitnej deklarácii presúvacích operácií. Preto Widget obe výslovne deklaruje a obe kopírovacie operácie odstraňuje.

Pri Pimpl môže hlavička obsahovať doprednú deklaráciu Impl a člen std::unique_ptr<Impl>. Predvolený deleter však vyžaduje úplný typ Impl: deštruktor môže zničiť vlastnený objekt a presúvacie priradenie môže zničiť pôvodný objekt cieľa. Funkcie deklarujte v hlavičke a deštruktor aj obe presúvacie operácie definujte pomocou = default v implementačnom súbore za definíciou Impl. Samotný presun ukazovateľa objekt nezničí, ale výnimka pri konštrukcii môže vyžadovať zničenie podobjektov. Preto tam patrí aj presúvací konštruktor.

Príklady

#include <iostream>
#include <memory>
#include <utility>

class Widget {
public:
    explicit Widget(int value);
    ~Widget();

    Widget(const Widget&) = delete;
    Widget& operator=(const Widget&) = delete;

    Widget(Widget&&) noexcept;
    Widget& operator=(Widget&&) noexcept;

    int value() const noexcept;

private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};

struct Widget::Impl {
    int value;
};

Widget::Widget(int value) : impl_(std::make_unique<Impl>(Impl{value})) {}
Widget::~Widget() = default;
Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;

int Widget::value() const noexcept {
    return impl_ ? impl_->value : -1;
}

int main() {
    Widget source(42);
    Widget intermediate(std::move(source));
    Widget target(7);
    target = std::move(intermediate);

    std::cout << target.value() << '\n'
              << source.value() << '\n'
              << intermediate.value() << '\n';
}

Výsledok

42
-1
-1

Jeden súbor napodobňuje rozdelenie na hlavičku a implementáciu. Presúvacia konštrukcia a následné presúvacie priradenie prenesú objekt s `42` do `target`, kde nahradí objekt so `7`. Oba zdrojové ukazovatele sú prázdne, takže `value()` pre každý vráti `-1`.

Súvisiace lekcie

  • C++ · Lekcia 11 · Pokročilá · Verzia: 3

Zdroje