Namespaces
Variants

    std::set<Key,Compare,Allocator>:: set

    From fr.cppreference.net

    C++
    Containers library
    std::set
    Member functions
    Non-member functions
    (until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
    Deduction guides (C++17)
    (1)
    set ( ) ;
    		(jusqu'à C++11)
    set ( ) : set ( Compare ( ) ) { }
    		(depuis C++11)
    (constexpr depuis C++26)
    explicit set ( const Compare & comp,
    const Allocator & alloc = Allocator ( ) ) ;
    		(2) (constexpr depuis C++26)
    explicit set ( const Allocator & alloc ) ;
    		(3) (depuis C++11)
    (constexpr depuis C++26)
    template < class InputIt >

    set ( InputIt first, InputIt last,
    const Compare & comp = Compare ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(4) (constexpr depuis C++26)
    template < class InputIt >

    set ( InputIt first, InputIt last,
    const Allocator & alloc )

    : set ( first, last, Compare ( ) , alloc ) { }
    		(5) (depuis C++14)
    (constexpr depuis C++26)
    set ( const set & other ) ;
    		(6) (constexpr depuis C++26)
    set ( const set & other, const Allocator & alloc ) ;
    		(7) (depuis C++11)
    (constexpr depuis C++26)
    set ( set && other ) ;
    		(8) (depuis C++11)
    (constexpr depuis C++26)
    set ( set && other, const Allocator & alloc ) ;
    		(9) (depuis C++11)
    (constexpr depuis C++26)
    set ( std:: initializer_list < value_type > init,

    const Compare & comp = Compare ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(10) (depuis C++11)
    (constexpr depuis C++26)
    set ( std:: initializer_list < value_type > init,

    const Allocator & alloc )

    : set ( init, Compare ( ) , alloc ) { }
    		(11) (depuis C++14)
    (constexpr depuis C++26)
    template < container-compatible-range < value_type > R >

    set ( std:: from_range_t , R && rg,
    const Compare & comp = Compare ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(12) (depuis C++23)
    (constexpr depuis C++26)
    template < container-compatible-range < value_type > R >

    set ( std:: from_range_t , R && rg,
    const Allocator & alloc )

    : set ( std:: from_range , std:: forward < R > ( rg ) , Compare ( ) , alloc ) { }
    		(13) (depuis C++23)
    (constexpr depuis C++26)

    Construit un nouveau conteneur à partir de diverses sources de données et optionnellement en utilisant l'allocateur fourni par l'utilisateur alloc ou l'objet fonction de comparaison comp .

    1-3) Construit un conteneur vide.
    4,5) Construit le conteneur avec le contenu de la plage [ first , last ) .
    Si [ first , last ) n'est pas un intervalle valide , le comportement est indéfini.
    6,7) Construit le conteneur avec la copie du contenu de other .

    Si alloc n'est pas fourni, l'allocateur est obtenu en appelant std:: allocator_traits < allocator_type > ::
    select_on_container_copy_construction ( other. get_allocator ( ) )     .

    		(depuis C++11)

    Pendant la déduction d'arguments de modèle de classe , seul le premier argument contribue à la déduction du paramètre de modèle Allocator du conteneur.

    		(depuis C++23)
    8,9) Construit le conteneur avec le contenu de other en utilisant la sémantique de déplacement. Si alloc n'est pas fourni, l'allocateur est obtenu par construction par déplacement depuis l'allocateur appartenant à other .

    Pendant la déduction d'arguments de modèle de classe , seul le premier argument contribue à la déduction du paramètre de modèle Allocator du conteneur.

    		(since C++23)
    10,11) Construit le conteneur avec le contenu de la liste d'initialisation init .
    12,13) Construit le conteneur avec le contenu de rg .

    Contenu

    Paramètres

    alloc - allocateur à utiliser pour toutes les allocations de mémoire de ce conteneur
    comp - objet fonction de comparaison à utiliser pour toutes les comparaisons de clés
    first, last - la paire d'itérateurs définissant la plage source des éléments à copier
    other - un autre conteneur à utiliser comme source pour initialiser les éléments du conteneur
    init - liste d'initialisation pour initialiser les éléments du conteneur
    rg - une plage compatible avec le conteneur , c'est-à-dire une input_range dont les éléments sont convertibles en value_type
    Exigences de type
    -
    InputIt doit satisfaire aux exigences de LegacyInputIterator .
    -
    Compare doit satisfaire aux exigences de Compare .
    -
    Allocator doit satisfaire aux exigences de Allocator .

    Complexité

    1-3) Constant.
    4,5) N·log(N) où N est std:: distance ( first, last ) en général, linéaire en N si [ first , last ) est déjà trié selon value_comp ( ) .
    6,7) Linéaire en fonction de la taille de other .
    8,9) Constant. Si alloc est fourni et alloc ! = other. get_allocator ( ) , alors linéaire.
    10,11) N·log(N) où N est init. size ( ) en général, linéaire en N si init est déjà trié selon value_comp ( ) .
    12,13) N·log(N) où N est ranges:: distance ( rg ) en général, linéaire en N si rg est déjà trié selon value_comp ( ) .

    Exceptions

    Les appels à Allocator::allocate peuvent lever une exception.

    Notes

    Après la construction par déplacement du conteneur (surcharge (8,9)), les références, pointeurs et itérateurs qui référençaient initialement des éléments dans other restent valides, mais référencent désormais des éléments qui se trouvent dans *this. La norme actuelle assure cette garantie via la déclaration générale dans [container.reqmts]/67, et une garantie plus directe est à l'étude via LWG issue 2321.

    Bien que n'étant pas officiellement requis avant C++23, certaines implémentations ont déjà placé le paramètre de modèle Allocator dans des contextes non déduits dans les modes antérieurs.

    Macro de test de fonctionnalitéValeur Norme Fonctionnalité
    __cpp_lib_containers_ranges 202202L (C++23) Construction et insertion compatibles avec les Ranges ; surcharges (12,13)

    Exemple

    Exécuter ce code 
    #include <cmath>
#include <iostream>
#include <set>
#include <string>
struct Point { double x, y; };
struct PointCmp
{
    bool operator()(const Point& lhs, const Point& rhs) const
    {
        return std::hypot(lhs.x, lhs.y) < std::hypot(rhs.x, rhs.y);
    }
};
std::ostream& operator<<(std::ostream& os, Point pt)
{
    return os << '(' << pt.x << ',' << pt.x << ')';
}
void println(auto rem, const auto& seq)
{
    std::cout << rem << '{';
    for (auto n{seq.size()}; const auto& elm : seq)
        std::cout << elm << (--n ? ", " : "");
    std::cout << "}\n";
}
int main()
{
    // (1) Constructeur par défaut
    std::set<std::string> a;
    a.insert("horse");
    a.insert("cat");
    a.insert("dog");
    println("1) a: ", a);
    // (4) Constructeur par plage
    std::set<std::string> b(a.find("dog"), a.end());
    println("2) b: ", b);
    // (6) Constructeur par copie
    std::set<std::string> c(a);
    c.insert("another horse");
    println("3) c: ", c);
    // (8) Constructeur par déplacement
    std::set<std::string> d(std::move(a));
    println("4) d: ", d);
    println("5) a: ", a);
    // (10) Constructeur par liste d'initialisation
    std::set<std::string> e{"one", "two", "three", "five", "eight"};
    println("6) e: ", e);
    // Comparaison personnalisée
    std::set<Point, PointCmp> f = {{2, 5}, {3, 4}, {1, 1}};
    f.insert({1, -1}); // Cela échoue car la magnitude de (1,-1) égale (1,1)
    println("7) f: ", f);
    // (12) Constructeur par plage
    const auto w = {"Eurybia", "Theia", "Rhea", "Aura", "Mnemosyne", "Mnemosyne"};
#if __cpp_lib_containers_ranges
    std::set<std::string> g(std::from_range, w); // surcharge (12)
#else
    std::set<std::string> g(w.begin(), w.end()); // repli sur (4)
#endif
    println("8) g: ", g);
}

    Sortie possible : 

    1) a: {chat, chien, cheval}
2) b: {chien, cheval}
3) c: {another horse, chat, chien, cheval}
4) d: {chat, chien, cheval}
5) a: {}
6) e: {huit, cinq, un, trois, deux}
7) f: {(1,1), (3,3), (2,2)}
8) g: {Aura, Eurybia, Mnemosyne, Rhea, Theia}
    **Notes sur la traduction :** - Les termes "another horse" dans la ligne 3 n'ont pas été traduits car ils font partie d'un ensemble de données qui semble être un exemple technique - Les noms propres (Aura, Eurybia, etc.) et les coordonnées numériques ont été conservés en anglais - La structure HTML et les attributs ont été préservés comme demandé - Les termes animaux et numéraux ont été traduits avec précision en français

    Rapports de défauts

    Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

    DR Appliqué à Comportement publié Comportement corrigé
    LWG 2076 C++11 surcharge ( 4 ) conditionnellement requise Key pour être CopyInsertable dans * this non requis
    LWG 2193 C++11 le constructeur par défaut était explicite rendu non-explicite

    Voir aussi

    		assigne des valeurs au conteneur
    (fonction membre publique)