Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

`= default` — explicitně výchozí definice funkcí v C++

`= default` požádá překladač o standardní definici funkce, která tento zápis připouští. Jeho význam ukazují vlastnictví prostředků, PImpl a virtuální destruktory.

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

Syntaxe

struct T {
    T() = default;
    T(const T&) = default;
    T(T&&) = default;
    T& operator=(const T&) = default;
    T& operator=(T&&) = default;
    ~T();
    bool operator==(const T&) const = default;
};
T::~T() = default;

V C++23 je = default; explicitní výchozí definice, nikoli přiřazení ani návěští default: v příkazu switch. Používá se pro speciální členské funkce (od C++11) a povolené porovnávací operátory (od C++20), například bool operator==(const T&) const = default;. Nelze ho použít na libovolnou funkci ani s výchozími argumenty. Podpora se může lišit podle implementace.

Funkce s = default v první deklaraci je deklarovaná uživatelem, ale není jím poskytnutá (user-provided). Pozdější definice, například T::~T() = default;, už je user-provided, což může ovlivnit trivialitu. Pokud člen nebo bázová třída brání požadované operaci, může být výchozí funkce definována jako odstraněná. Stane-li se to při použití = default až po první deklaraci, program není správně utvořený.

V const T& deklaruje & referenci na lvalue, v T&& deklaruje && referenci na rvalue. Jde o běžné typy parametrů pro kopírování a přesun. = delete výslovně zakazuje použití funkce: vybere-li ji řešení přetížení, volání je neplatné. Nejde o výraz delete, který slouží ke zničení objektu a uvolnění jeho paměti. Typ obsahující std::future může přesunout přístup ke sdílenému stavu, ale nemůže ho kopírovat po členech.

U PImpl deklaruj Impl v hlavičce bez definice a ulož std::unique_ptr<Impl>. Výchozí mazací funkce vyžaduje úplný typ Impl, proto definuj destruktor mimo třídu až za definicí Impl. Uživatelem deklarovaný destruktor zabrání implicitní deklaraci obou přesunových operací. Pokud je potřebuješ, deklaruj je a na stejném místě je definuj pomocí = default. Přesunové přiřazení může odstranit předchozí Impl cíle. std::unique_ptr nelze kopírovat a inicializační seznam konstruktoru inicializuje členskou proměnnou, která prostředek vlastní.

V polymorfním rozhraní strategie označuje = 0 čistě virtuální funkci. Naproti tomu virtual ~Strategy() = default; definuje veřejný virtuální destruktor, aby se objekt odvozené třídy správně zničil prostřednictvím std::unique_ptr<Strategy>. Volající předává strategii konstruktorem. Registr továren může přiřadit názvy továrnám strategií, které už jsou přeložené a přilinkované k programu, bez načítání dynamických knihoven.

Příklady

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

struct Strategy {
    virtual ~Strategy() = default;
    virtual int apply(int value) const = 0;
};

struct Double final : Strategy {
    int apply(int value) const override { return 2 * value; }
};

class Task {
public:
    explicit Task(std::unique_ptr<Strategy> strategy);
    ~Task();
    Task(Task&&) noexcept;
    Task& operator=(Task&&) noexcept;
    Task(const Task&) = delete;
    Task& operator=(const Task&) = delete;
    int run() const;

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

struct Task::Impl {
    explicit Impl(std::unique_ptr<Strategy> s) : strategy(std::move(s)) {}
    std::unique_ptr<Strategy> strategy;
};

Task::Task(std::unique_ptr<Strategy> s)
    : impl_(std::make_unique<Impl>(std::move(s))) {}
Task::~Task() = default;
Task::Task(Task&&) noexcept = default;
Task& Task::operator=(Task&&) noexcept = default;

int Task::run() const {
    if (!impl_ || !impl_->strategy) {
        throw std::logic_error("no strategy");
    }
    return impl_->strategy->apply(21);
}

int main() {
    Task original(std::make_unique<Double>());
    Task owner(std::move(original));
    std::cout << owner.run() << '\n';
}

Výsledek

42

`main` předá strategii `Double` a výchozí přesunový konstruktor přenese vlastnictví `Impl` z `original` do `owner`. Virtuální volání `Double::apply(21)` vrátí `42`. Ukázka objekt nekopíruje a po přesunu nevolá `run()` na zdrojovém objektu.

Související lekce

  • C++ · Lekce 45 · Pokročilá · Verze: 3
  • C++ · Lekce 57 · Pokročilá · Verze: 3
  • C++ · Lekce 59 · Pokročilá · Verze: 3

Zdroje