WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

`= default` — explizit standardmäßig definierte Funktionen in C++

Mit `= default` erzeugt der Compiler die Standarddefinition einer dafür zulässigen Funktion. Ressourcenbesitz, PImpl und virtuelle Destruktoren zeigen den praktischen Einsatz.

Version: 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 ist = default; eine explizite Standarddefinition, keine Zuweisung und keine switch-Marke (default:). Die Schreibweise gilt für spezielle Memberfunktionen (seit C++11) und zulässige Vergleichsoperatoren (seit C++20), etwa bool operator==(const T&) const = default;. Beliebige Funktionen lassen sich damit nicht definieren; Standardargumente sind nicht erlaubt. Die Unterstützung kann je nach Implementierung variieren.

Steht = default in der ersten Deklaration, ist die Funktion benutzerdeklariert, aber nicht benutzerbereitgestellt (user-provided). Eine spätere Definition wie T::~T() = default; ist dagegen user-provided, was die Trivialität beeinflussen kann. Verhindert ein Datenelement oder eine Basisklasse die erforderliche Operation, kann die Funktion als gelöscht definiert werden. Geschieht das beim Defaulten nach der ersten Deklaration, ist das Programm nicht wohlgeformt.

In const T& steht & für eine Lvalue-Referenz, in T&& steht && für eine Rvalue-Referenz. Das sind typische Parametertypen für Kopier- und Verschiebeoperationen. = delete verbietet die Verwendung einer Funktion ausdrücklich: Wählt die Überladungsauflösung sie aus, ist der Aufruf nicht wohlgeformt. Das ist kein delete-Ausdruck, der ein Objekt zerstört und seinen Speicher freigibt. Ein Typ mit std::future kann den Zugriff auf den gemeinsamen Zustand verschieben, aber das entsprechende Member nicht kopieren.

Bei PImpl wird Impl im Header vorwärtsdeklariert und ein std::unique_ptr<Impl> gespeichert. Weil der Standardlöscher einen vollständigen Typ Impl voraussetzt, definiert man den Destruktor außerhalb der Klasse nach der Definition von Impl. Ein benutzerdeklarierter Destruktor verhindert die implizite Deklaration beider Verschiebeoperationen. Bei Bedarf deklariert man sie selbst und definiert sie ebenfalls dort mit = default. Eine Verschiebezuweisung kann das bisherige Impl des Ziels löschen. std::unique_ptr ist nicht kopierbar; die Member-Initialisierungsliste des Konstruktors initialisiert das besitzende Member.

In einer polymorphen Strategieschnittstelle kennzeichnet = 0 eine rein virtuelle Funktion. Dagegen definiert virtual ~Strategy() = default; einen öffentlichen virtuellen Destruktor, damit ein abgeleitetes Objekt über std::unique_ptr<Strategy> korrekt zerstört wird. Der Aufrufer übergibt die Strategie über den Konstruktor. Eine Fabrikregistrierung kann Namen den Fabriken bereits kompilierten und eingebundenen Strategien zuordnen, ohne dynamische Bibliotheken zu laden.

Beispiele

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

Ergebnis

42

`main` übergibt `Double` an den Konstruktor. Dann überträgt der mit `= default` definierte Verschiebekonstruktor den Besitz von `Impl` von `original` an `owner`. Der virtuelle Aufruf von `Double::apply(21)` ergibt `42`. Das Beispiel kopiert das Objekt nicht und ruft `run()` nicht auf dem verschobenen Quellobjekt auf.

Zugehörige Lektionen

  • C++ · Lektion 45 · Fortgeschritten · Version: 3
  • C++ · Lektion 57 · Fortgeschritten · Version: 3
  • C++ · Lektion 59 · Fortgeschritten · Version: 3

Quellen