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
- WG21 N4950 — Working Draft, Standard for Programming Language C++ (C++23)
- Explicitly-defaulted functions [dcl.fct.def.default]
- Deleted definitions [dcl.fct.def.delete]
- Constructors [class.ctor]
- Copy/move assignment operator [class.copy.assign]
- Defaulted comparison operator functions [class.compare.default]
- Class template future [futures.unique.future]
- Default deleter [unique.ptr.dltr.dflt]
- GotW #7b Solution: Minimizing Compile-Time Dependencies, Part 2
- Abstract classes [class.abstract]
- Delete expressions [expr.delete]