Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

`= default` — fonctions explicitement définies par défaut en C++

`= default` demande au compilateur de fournir la définition standard d’une fonction admissible. La propriété d’une ressource, PImpl et les destructeurs virtuels en illustrent l’intérêt.

Version : 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;

En C++23, = default; est une définition explicitement mise par défaut, et non une affectation ni une étiquette default: de switch. Cette syntaxe s’applique aux fonctions membres spéciales (depuis C++11) et aux opérateurs de comparaison admissibles (depuis C++20), par exemple bool operator==(const T&) const = default;. Elle ne s’applique pas à une fonction quelconque et n’autorise pas les arguments par défaut. La prise en charge peut varier selon l’implémentation.

Une fonction mise par défaut dès sa première déclaration est déclarée par l’utilisateur, mais pas fournie par lui (user-provided). Une définition ultérieure comme T::~T() = default; est en revanche user-provided, ce qui peut influer sur son caractère trivial. Si un membre ou une classe de base empêche l’opération requise, la fonction peut être définie comme supprimée. Si cela se produit lors d’une définition par défaut postérieure à la première déclaration, le programme est mal formé.

Dans const T&, & déclare une référence lvalue ; dans T&&, && déclare une référence rvalue. Ce sont des types de paramètres typiques pour la copie et le déplacement. = delete interdit explicitement l’utilisation d’une fonction : si la résolution de surcharge la sélectionne, l’appel est mal formé. Ce n’est pas une expression delete, qui sert à détruire un objet et à libérer sa mémoire. Un type contenant un std::future peut déplacer le handle vers l’état partagé, mais ne peut pas le copier membre par membre.

Avec PImpl, déclarez Impl sans le définir dans l’en-tête et stockez un std::unique_ptr<Impl>. Le suppresseur par défaut exige que Impl soit complet : définissez donc le destructeur hors de la classe, après la définition de Impl. Un destructeur déclaré par l’utilisateur empêche la déclaration implicite des deux opérations de déplacement ; si nécessaire, déclarez-les et définissez-les au même endroit avec = default. L’affectation par déplacement peut supprimer l’ancien Impl de la destination. std::unique_ptr n’est pas copiable, et la liste d’initialisation du constructeur initialise le membre propriétaire.

Dans une interface de stratégie polymorphe, = 0 marque une fonction virtuelle pure. À l’inverse, virtual ~Strategy() = default; définit un destructeur virtuel public qui permet de détruire correctement un objet dérivé via std::unique_ptr<Strategy>. L’appelant injecte la stratégie via le constructeur. Un registre de fabriques peut associer des noms aux fabriques de stratégies déjà compilées et liées au programme, sans chargement de bibliothèques dynamiques.

Exemples

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

Résultat

42

`main` injecte `Double`, puis le constructeur de déplacement défini par défaut transfère la propriété de `Impl` de `original` à `owner`. L’appel virtuel à `Double::apply(21)` donne `42`. L’exemple ne copie pas l’objet et n’appelle pas `run()` sur l’objet source après le déplacement.

Leçons associées

  • C++ · Leçon 45 · Avancé · Version : 3
  • C++ · Leçon 57 · Avancé · Version : 3
  • C++ · Leçon 59 · Avancé · Version : 3

Sources