KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

`= default` — expliciet standaardgedefinieerde functies in C++

Met `= default` laat je de compiler de standaarddefinitie van een daarvoor geschikte functie leveren. Eigenaarschap, PImpl en virtuele destructors laten zien wanneer dat nuttig is.

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

Syntax

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;

In C++23 geeft = default; een expliciete standaarddefinitie aan; het is geen toewijzing en geen default:-label in een switch. Je kunt het gebruiken voor speciale lidfuncties (sinds C++11) en toegestane vergelijkingsoperatoren (sinds C++20), zoals bool operator==(const T&) const = default;. Het is niet bedoeld voor willekeurige functies en staat geen standaardargumenten toe. Ondersteuning kan per implementatie verschillen.

Een functie met = default op de eerste declaratie is door de gebruiker gedeclareerd, maar niet door de gebruiker geleverd (user-provided). Een latere definitie zoals T::~T() = default; is wel user-provided, wat invloed kan hebben op de trivialiteit. Als een lid of basisklasse de vereiste bewerking verhindert, kan de functie als verwijderd worden gedefinieerd. Gebeurt dat bij = default na de eerste declaratie, dan is het programma ongeldig.

In const T& declareert & een lvalue-referentie; in T&& declareert && een rvalue-referentie. Dit zijn gebruikelijke parametertypen voor kopiëren en verplaatsen. = delete verbiedt expliciet het gebruik van een functie: kiest de overloadresolutie die functie, dan is de aanroep ongeldig. Dit is geen delete-expressie, die een object vernietigt en zijn geheugen vrijgeeft. Een type met een std::future kan de handle naar de gedeelde toestand verplaatsen, maar kan die niet lid voor lid kopiëren.

Declareer bij PImpl het type Impl in de header zonder het te definiëren en bewaar een std::unique_ptr<Impl>. De standaardverwijderaar vereist een compleet type Impl, dus definieer de destructor buiten de klasse, na de definitie van Impl. Een door de gebruiker gedeclareerde destructor voorkomt de impliciete declaratie van beide verplaatsingsbewerkingen. Declareer ze zo nodig zelf en definieer ze daar ook met = default. Verplaatsingstoewijzing kan het vorige Impl van het doel verwijderen. std::unique_ptr is niet kopieerbaar; de initialisatielijst van de constructor initialiseert het lid dat eigenaar is.

In een polymorfe strategie-interface markeert = 0 een puur virtuele functie. virtual ~Strategy() = default; definieert daarentegen een publieke virtuele destructor, zodat een afgeleid object via std::unique_ptr<Strategy> correct wordt vernietigd. De aanroeper injecteert de strategie via de constructor. Een factoryregister kan namen koppelen aan factory's van strategieën die al gecompileerd en aan het programma gelinkt zijn, zonder dynamische bibliotheken te laden.

Voorbeelden

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

Resultaat

42

`main` injecteert `Double`, waarna de standaardgedefinieerde verplaatsingsconstructor het eigenaarschap van `Impl` overdraagt van `original` aan `owner`. De virtuele aanroep van `Double::apply(21)` levert `42` op. Het voorbeeld kopieert het object niet en roept `run()` niet aan op het bronobject na de verplaatsing.

Gerelateerde lessen

  • C++ · Les 45 · Gevorderd · Versie: 3
  • C++ · Les 57 · Gevorderd · Versie: 3
  • C++ · Les 59 · Gevorderd · Versie: 3

Bronnen