CKTIS / C++
Fonctions membres spéciales avec `= default` en C++
En C++23, `= default` demande au compilateur la définition standard d’une fonction membre spéciale. Avec Pimpl, son emplacement compte ; la prise en charge de C++23 varie selon l’implémentation.
Version : ISO C++23; implementation support may vary
Syntaxe
struct S {
S() = default;
S(const S&) = default;
S(S&&) = default;
S& operator=(const S&) = default;
S& operator=(S&&) = default;
~S();
};
S::~S() = default;= default demande au compilateur de définir, selon les règles du langage, un constructeur par défaut, un constructeur de copie ou de déplacement, un opérateur d’affectation par copie ou par déplacement, ou un destructeur. Il ne s’agit pas d’un corps vide {} : la fonction générée applique les règles de l’opération aux sous-objets des classes de base et aux membres de données non statiques.
Avec = default dès la première déclaration, la fonction est déclarée par l’utilisateur, mais n’est pas user-provided au sens de la norme. Elle peut être triviale si les autres conditions sont remplies, ou être définie comme supprimée si une opération requise sur un sous-objet est indisponible. Si = default n’apparaît que dans une définition ultérieure, la fonction est user-provided et n’est pas triviale. Si la définition générée devait être supprimée, le programme est mal formé.
= delete est différent : une surcharge supprimée participe toujours à la résolution de surcharge, mais sa sélection est une erreur. Ce n’est pas une expression delete p et aucune mémoire n’est libérée. Un destructeur déclaré par l’utilisateur, même avec = default, empêche la déclaration implicite des opérations de déplacement. Widget déclare donc explicitement les deux et supprime les deux opérations de copie.
Avec Pimpl, l’en-tête peut déclarer Impl par anticipation et contenir un std::unique_ptr<Impl>. Le suppresseur par défaut exige toutefois que Impl soit complet : le destructeur peut supprimer l’objet détenu, et l’affectation par déplacement peut supprimer l’ancien objet de la cible. Déclarez les fonctions dans l’en-tête, puis définissez le destructeur et les deux opérations de déplacement avec = default dans le fichier d’implémentation, après la définition de Impl. Le déplacement du pointeur seul ne détruit rien ; en revanche, une exception pendant la construction peut nécessiter la destruction de sous-objets. C’est pourquoi le constructeur de déplacement est lui aussi défini à cet endroit.
Exemples
#include <iostream>
#include <memory>
#include <utility>
class Widget {
public:
explicit Widget(int value);
~Widget();
Widget(const Widget&) = delete;
Widget& operator=(const Widget&) = delete;
Widget(Widget&&) noexcept;
Widget& operator=(Widget&&) noexcept;
int value() const noexcept;
private:
struct Impl;
std::unique_ptr<Impl> impl_;
};
struct Widget::Impl {
int value;
};
Widget::Widget(int value) : impl_(std::make_unique<Impl>(Impl{value})) {}
Widget::~Widget() = default;
Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;
int Widget::value() const noexcept {
return impl_ ? impl_->value : -1;
}
int main() {
Widget source(42);
Widget intermediate(std::move(source));
Widget target(7);
target = std::move(intermediate);
std::cout << target.value() << '\n'
<< source.value() << '\n'
<< intermediate.value() << '\n';
}Résultat
42 -1 -1
Un seul fichier reproduit la séparation entre l’en-tête et l’implémentation. La construction puis l’affectation par déplacement transfèrent à `target` l’objet contenant `42`, à la place de celui contenant `7`. Les deux pointeurs sources sont vides : `value()` renvoie `-1` pour chacun.
Leçons associées
- C++ · Leçon 11 · Avancé · Version : 3