Namespaces
Variants

    std:: unordered_set

    From fr.cppreference.net
    C++
    Containers library
    std::unordered_set
    Member types
    Member functions
    Non-member functions
    Deduction guides (C++17)
    Défini dans l'en-tête <unordered_set>
    template <

    class Key,
    class Hash = std:: hash < Key > ,
    class KeyEqual = std:: equal_to < Key > ,
    class Allocator = std:: allocator < Key >

    > class unordered_set ;
    		(1) (depuis C++11)
    namespace pmr {

    template <
    class Key,
    class Hash = std:: hash < Key > ,
    class Pred = std:: equal_to < Key >
    > using unordered_set = std :: unordered_set < Key, Hash, Pred,
    std:: pmr :: polymorphic_allocator < Key >> ;

    }
    		(2) (depuis C++17)

    std::unordered_set est un conteneur associatif qui contient un ensemble d'objets uniques de type Key . La recherche, l'insertion et la suppression ont une complexité temporelle moyenne constante.

    En interne, les éléments ne sont pas triés dans un ordre particulier, mais organisés en compartiments. Le compartiment dans lequel un élément est placé dépend entièrement du hachage de sa valeur. Cela permet un accès rapide aux éléments individuels, car une fois le hachage calculé, il fait référence au compartiment exact où l'élément est placé.

    Les éléments du conteneur ne doivent pas être modifiés (même par des itérateurs non constants) car une modification pourrait changer le hachage d'un élément et corrompre le conteneur.

    std::unordered_set satisfait aux exigences de Container , AllocatorAwareContainer , UnorderedAssociativeContainer .

    Toutes les fonctions membres de std::unordered_set sont constexpr : il est possible de créer et d'utiliser des objets std::unordered_set lors de l'évaluation d'une expression constante.

    Cependant, std::unordered_set ne peut généralement pas être constexpr , car toute mémoire allouée dynamiquement doit être libérée lors de la même évaluation d'expression constante.

    		(depuis C++26)

    Contenu

    Invalidation des itérateurs

    Opérations Invalidations
    Toutes les opérations en lecture seule, swap , std::swap Jamais
    clear , rehash , reserve , operator= Toujours
    insert , emplace , emplace_hint Seulement si provoque un rehash
    erase Uniquement pour l'élément effacé

    Notes

    • Les fonctions d'échange n'invalident aucun des itérateurs à l'intérieur du conteneur, mais elles invalident l'itérateur marquant la fin de la région d'échange.
    • Les références et les pointeurs vers les données stockées dans le conteneur ne sont invalidés que par l'effacement de cet élément, même lorsque l'itérateur correspondant est invalidé.
    • Après une affectation par déplacement de conteneur, sauf si l'affectation par déplacement élément par élément est forcée par des allocateurs incompatibles, les références, pointeurs et itérateurs (autres que l'itérateur de fin) vers le conteneur déplacé restent valides, mais se réfèrent aux éléments qui se trouvent maintenant dans * this .

    Paramètres du modèle

    Cette section est incomplète
    Motif : Ajouter les descriptions des paramètres du modèle.

    Types membres

    Type Définition
    key_type Key
    value_type Key
    size_type type entier non signé (généralement std::size_t)
    difference_type type entier signé (généralement std::ptrdiff_t)
    hasher Hash
    key_equal KeyEqual
    allocator_type Allocator
    reference value_type&
    const_reference const value_type&
    pointer std::allocator_traits<Allocator>::pointer
    const_pointer std::allocator_traits<Allocator>::const_pointer
    iterator Constant LegacyForwardIterator et ConstexprIterator(depuis C++26) vers value_type
    const_iterator LegacyForwardIterator et ConstexprIterator(depuis C++26) vers const value_type
    local_iterator un type d'itérateur dont les types catégorie, valeur, différence, pointeur et
    types référence sont les mêmes que iterator. Cet itérateur
    peut être utilisé pour itérer à travers un seul compartiment mais pas à travers plusieurs compartiments
    const_local_iterator un type d'itérateur dont les types catégorie, valeur, différence, pointeur et
    types référence sont les mêmes que const_iterator. Cet itérateur
    peut être utilisé pour itérer à travers un seul compartiment mais pas à travers plusieurs compartiments
    node_type (depuis C++17) une spécialisation de node handle représentant un nœud de conteneur
    insert_return_type (depuis C++17) type décrivant le résultat de l'insertion d'un node_type, une spécialisation de 
    template< class Iter, class NodeType >
struct /* unspecified */
{
    Iter     position;
    bool     inserted;
    NodeType node;
};

    instanciée avec les arguments de modèle iterator et node_type.

    Fonctions membres

    		construit le unordered_set
    (fonction membre publique)
    		détruit l' unordered_set
    (fonction membre publique)
    		assigne des valeurs au conteneur
    (fonction membre publique)
    		retourne l'allocateur associé
    (fonction membre publique)
    Itérateurs
    		retourne un itérateur vers le début
    (fonction membre publique)
    		retourne un itérateur vers la fin
    (fonction membre publique)
    Capacité
    		vérifie si le conteneur est vide
    (fonction membre publique)
    		retourne le nombre d'éléments
    (fonction membre publique)
    		retourne le nombre maximum possible d'éléments
    (fonction membre publique)
    Modificateurs
    		efface le contenu
    (fonction membre publique)
    		insère des éléments ou des nœuds (depuis C++17)
    (fonction membre publique)
    (C++23)
    		insère une plage d'éléments
    (fonction membre publique)
    		construit un élément en place
    (fonction membre publique)
    		construit des éléments en place en utilisant un indice
    (fonction membre publique)
    		supprime des éléments
    (fonction membre publique)
    		échange le contenu
    (fonction membre publique)
    (C++17)
    		extrait les nœuds du conteneur
    (fonction membre publique)
    (C++17)
    		fusionne les nœuds d'un autre conteneur
    (fonction membre publique)
    Recherche
    		retourne le nombre d'éléments correspondant à une clé spécifique
    (fonction membre publique)
    		trouve l'élément avec une clé spécifique
    (fonction membre publique)
    (C++20)
    		vérifie si le conteneur contient un élément avec une clé spécifique
    (fonction membre publique)
    		renvoie la plage d'éléments correspondant à une clé spécifique
    (fonction membre publique)
    Interface de compartiment
    		retourne un itérateur vers le début du compartiment spécifié
    (fonction membre publique)
    		retourne un itérateur vers la fin du compartiment spécifié
    (fonction membre publique)
    		renvoie le nombre de compartiments
    (fonction membre publique)
    		retourne le nombre maximum de compartiments
    (fonction membre publique)
    		renvoie le nombre d'éléments dans un bucket spécifique
    (fonction membre publique)
    		renvoie le compartiment pour une clé spécifique
    (fonction membre publique)
    Politique de hachage
    		retourne le nombre moyen d'éléments par compartiment
    (fonction membre publique)
    		gère le nombre moyen maximum d'éléments par compartiment
    (fonction membre publique)
    		réserve au moins le nombre spécifié de compartiments et régénère la table de hachage
    (fonction membre publique)
    		réserve de l'espace pour au moins le nombre spécifié d'éléments et régénère la table de hachage
    (fonction membre publique)
    Observateurs
    		retourne la fonction utilisée pour hacher les clés
    (fonction membre publique)
    		renvoie la fonction utilisée pour comparer les clés pour l'égalité
    (fonction membre publique)

    Fonctions non membres

    (C++11) (C++11) (removed in C++20)
    		compare les valeurs dans l'unordered_set
    (modèle de fonction)
    (C++11)
    		spécialise l'algorithme std::swap
    (modèle de fonction)
    (C++20)
    		efface tous les éléments satisfaisant des critères spécifiques
    (modèle de fonction)

    Guides de déduction

    		(depuis C++17)

    Notes

    Les types membres iterator et const_iterator peuvent être des alias vers le même type. Cela signifie que définir une paire de surcharges de fonction utilisant ces deux types comme types de paramètres peut violer la Règle de Définition Unique . Étant donné que iterator est convertible en const_iterator , une fonction unique avec un const_iterator comme type de paramètre fonctionnera à la place.

    Macro de test de fonctionnalité Valeur Std Fonctionnalité
    __cpp_lib_containers_ranges 202202L (C++23) Construction et insertion de plages pour les conteneurs
    __cpp_lib_constexpr_unordered_set 202502L (C++26) constexpr std::unordered_set

    Exemple

    Exécuter ce code 
    #include <iostream>
#include <unordered_set>
void print(const auto& set)
{
    for (const auto& elem : set)
        std::cout << elem << ' ';
    std::cout << '\n';
}
int main()
{
    std::unordered_set<int> mySet{2, 7, 1, 8, 2, 8}; // crée un ensemble d'entiers
    print(mySet);
    mySet.insert(5); // insère un élément 5 dans l'ensemble
    print(mySet);
    if (auto iter = mySet.find(5); iter != mySet.end())
        mySet.erase(iter); // supprime l'élément pointé par iter
    print(mySet);
    mySet.erase(7); // supprime l'élément 7
    print(mySet);
}

    Sortie possible : 

    8 1 7 2
5 8 1 7 2
8 1 7 2
8 1 2

    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 Applicable à Comportement publié Comportement corrigé
    LWG 2050 C++11 les définitions de reference , const_reference , pointer
    et const_pointer étaient basées sur allocator_type     		basées sur value_type et
    std::allocator_traits

    Voir aussi

    (C++11)
    		collection de clés, hachée par clés
    (modèle de classe)
    		collection de clés uniques, triée par clés
    (modèle de classe)
    (C++23)
    		adapte un conteneur pour fournir une collection de clés uniques, triée par clés
    (modèle de classe)