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

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 .

Paramètres

Complexité

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 (à l'exception de l'itérateur de fin) vers other restent valides, mais se réfèrent aux éléments qui se trouvent désormais dans * this . La norme actuelle garantit cela via l'énoncé général dans [container.reqmts]/67 , et une garantie plus directe est à l'étude via LWG issue 2321 .

Si plusieurs éléments de la plage ont des clés équivalentes, il n'est pas spécifié quel élément est inséré (en attente de LWG2844 ).

Bien que non formellement requis avant C++23, certaines implémentations ont déjà placé le paramètre template Allocator dans des contextes non déduits dans les modes antérieurs.

Exemple

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

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}

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.

Voir aussi