std:: semiregular

#include <concepts>
#include <iostream>
template<std::semiregular T>
// Crédit Alexander Stepanov
// les concepts sont des exigences sur T
// Exigence sur T : T est semiregular
// T a(b); ou T a = b; => constructeur de copie
// T a; => constructeur par défaut
// a = b; => assignation
struct Single
{
    T value;
    // L'initialisation par agrégation pour Single se comporte comme le constructeur suivant :
    // explicit Single(const T& x) : value(x) {}
    // Les fonctions membres spéciales déclarées implicitement se comportent comme les définitions suivantes,
    // sauf qu'elles peuvent avoir des propriétés supplémentaires :
    // Single(const Single& x) : value(x.value) {}
    // Single() {}
    // ~Single() {}
    // Single& operator=(const Single& x) { value = x.value; return *this; }
    // l'opérateur de comparaison n'est pas défini ; il n'est pas requis par le concept `semiregular`
    // bool operator==(Single const& other) const = delete;
};
void print(std::semiregular auto x)
{
    std::cout << x.value << '\n';
}
int main()
{
    Single<int> myInt1{4};      // initialisation par agrégation : myInt1.value = 4
    Single<int> myInt2(myInt1); // constructeur de copie
    Single<int> myInt3;         // constructeur par défaut
    myInt3 = myInt2;            // opérateur d'assignation par copie
//  myInt1 == myInt2;           // Erreur : operator== n'est pas défini
    print(myInt1); // ok : Single<int> est un type `semiregular`
    print(myInt2);
    print(myInt3);
}   // Les variables Single<int> sont détruites ici