Namespaces
Variants

    std::unordered_multiset<Key,Hash,KeyEqual,Allocator>:: unordered_multiset

    From fr.cppreference.net

    C++
    Containers library
    std::unordered_multiset
    Member types
    Member functions
    Non-member functions
    Deduction guides (C++17)
    (1)
    unordered_multiset ( )
    : unordered_multiset ( size_type ( /* unspecified */ ) ) { }
    		(depuis C++11)
    (jusqu'à C++20)
    unordered_multiset ( ) ;
    		(depuis C++20)
    explicit unordered_multiset ( size_type bucket_count,

    const Hash & hash = Hash ( ) ,
    const key_equal & equal = key_equal ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(2) (depuis C++11)
    unordered_multiset ( size_type bucket_count,

    const Allocator & alloc )

    : unordered_multiset ( bucket_count, Hash ( ) , key_equal ( ) , alloc ) { }
    		(3) (depuis C++14)
    unordered_multiset ( size_type bucket_count,

    const Hash & hash,
    const Allocator & alloc )

    : unordered_multiset ( bucket_count, hash, key_equal ( ) , alloc ) { }
    		(4) (depuis C++14)
    explicit unordered_multiset ( const Allocator & alloc ) ;
    		(5) (depuis C++11)
    template < class InputIt >

    unordered_multiset ( InputIt first, InputIt last,
    size_type bucket_count = /* non spécifié */ ,
    const Hash & hash = Hash ( ) ,
    const key_equal & equal = key_equal ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(6) (depuis C++11)
    template < class InputIt >

    unordered_multiset ( InputIt first, InputIt last,
    size_type bucket_count,
    const Allocator & alloc )
    : unordered_multiset ( first, last,

    bucket_count, Hash ( ) , key_equal ( ) , alloc ) { }
    		(7) (depuis C++14)
    template < class InputIt >

    unordered_multiset ( InputIt first, InputIt last,
    size_type bucket_count,
    const Hash & hash,
    const Allocator & alloc )
    : unordered_multiset ( first, last,

    bucket_count, hash, key_equal ( ) , alloc ) { }
    		(8) (depuis C++14)
    unordered_multiset ( const unordered_multiset & other ) ;
    		(9) (depuis C++11)
    unordered_multiset ( const unordered_multiset & other, const Allocator & alloc ) ;
    		(10) (depuis C++11)
    unordered_multiset ( unordered_multiset && other ) ;
    		(11) (depuis C++11)
    unordered_multiset ( unordered_multiset && other, const Allocator & alloc ) ;
    		(12) (depuis C++11)
    unordered_multiset ( std:: initializer_list < value_type > init,

    size_type bucket_count = /* non spécifié */ ,
    const Hash & hash = Hash ( ) ,
    const key_equal & equal = key_equal ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(13) (depuis C++11)
    unordered_multiset ( std:: initializer_list < value_type > init,

    size_type bucket_count,
    const Allocator & alloc )
    : unordered_multiset ( init, bucket_count,

    Hash ( ) , key_equal ( ) , alloc ) { }
    		(14) (depuis C++14)
    unordered_multiset ( std:: initializer_list < value_type > init,

    size_type bucket_count,
    const Hash & hash,
    const Allocator & alloc )
    : unordered_multiset ( init, bucket_count,

    hash, key_equal ( ) , alloc ) { }
    		(15) (depuis C++14)
    template < container-compatible-range < value_type > R >

    unordered_multiset ( std:: from_range_t , R && rg,
    size_type bucket_count = /* voir description */ ,
    const Hash & hash = Hash ( ) ,
    const key_equal & equal = key_equal ( ) ,

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

    unordered_multiset ( std:: from_range_t , R && rg,
    size_type bucket_count,
    const Allocator & alloc )
    : unordered_multiset ( std:: from_range , std:: forward < R > ( rg ) ,

    bucket_count, Hash ( ) , key_equal ( ) , alloc ) { }
    		(17) (depuis C++23)
    template < container-compatible-range < value_type > R >

    unordered_multiset ( std:: from_range_t , R && rg,
    size_type bucket_count,
    const Hash & hash,
    const Alloc & alloc )
    : unordered_multiset ( std:: from_range , std:: forward < R > ( rg ) ,

    bucket_count, hash, key_equal ( ) , alloc ) { }
    		(18) (depuis C++23)

    Construit un nouveau conteneur à partir de diverses sources de données. Utilise optionnellement le bucket_count fourni par l'utilisateur comme nombre minimal de compartiments à créer, hash comme fonction de hachage, equal comme fonction de comparaison des clés et alloc comme allocateur.

    1-5) Construit un conteneur vide. Définit max_load_factor() à 1.0 . Pour le constructeur par défaut, le nombre de compartiments n'est pas spécifié.
    6-8) Construit le conteneur avec le contenu de la plage [ first , last ) . Définit max_load_factor() à 1.0 .
    9,10) Constructeur de copie. Construit le conteneur avec la copie du contenu de other , copie le facteur de charge, le prédicat et la fonction de hachage également. 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 ( ) ) .

    Le paramètre template Allocator est uniquement déduit du premier argument lorsqu'il est utilisé dans la déduction d'arguments de template de classe .

    		(depuis C++23)
    11,12) Constructeur de déplacement . 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 .

    Le paramètre template Allocator est uniquement déduit du premier argument lors de son utilisation dans la déduction d'arguments de template de classe .

    		(depuis C++23)
    13-15) Constructeur de liste d'initialisation . Construit le conteneur avec le contenu de la liste d'initialisation init , identique à unordered_multiset ( init. begin ( ) , init. end ( ) ) .
    16-18) Construit le conteneur avec le contenu de rg .

    Sommaire

    Paramètres

    alloc - allocateur à utiliser pour toutes les allocations de mémoire de ce conteneur
    bucket_count - nombre minimal de buckets à utiliser lors de l'initialisation. S'il n'est pas spécifié, une valeur par défaut non spécifiée est utilisée
    hash - fonction de hachage à utiliser
    equal - fonction de comparaison à utiliser pour toutes les comparaisons de clés de ce conteneur
    first, last - la paire d'itérateurs définissant la plage source des éléments à copier
    rg - une plage compatible avec le conteneur , c'est-à-dire une input_range dont les éléments sont convertibles en value_type
    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
    Exigences de type
    -
    InputIt doit satisfaire aux exigences de LegacyInputIterator .

    Complexité

    1-5) Constant.
    6-8) Cas moyen linéaire (c'est-à-dire O(N) , où N est std:: distance ( first, last ) ), cas pire quadratique, c'est-à-dire O(N 2 ) .
    9,10) Linéaire en fonction de la taille de other .
    11,12) Constant. Si alloc est fourni et alloc ! = other. get_allocator ( ) , alors linéaire.
    13-15) Cas moyen O(N) ( N est std:: size ( init ) ), cas le plus défavorable O(N 2 ) .
    16-18) Cas moyen O(N) ( N est ranges:: distance ( rg ) ), cas le plus défavorable O(N 2 ) .

    Exceptions

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

    Notes

    Après la construction par déplacement du conteneur (surcharge (4)), les références, pointeurs et itérateurs qui référençaient initialement des éléments dans other restent valides, mais se réfèrent à des éléments qui sont maintenant dans *this. La norme actuelle fournit cette garantie par le biais de l'énoncé général dans [container.reqmts]/67, et une garantie plus directe est à l'étude via LWG issue 2321.

    Bien que n'étant pas formellement exigé 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.

    Feature-test macro Valeur Norme Fonctionnalité
    __cpp_lib_containers_ranges 202202L (C++23) compatible avec les plages construction et insertion ; surcharges (16-18)

    Exemple

    Cette section est incomplète
    Raison : aucun exemple

    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 2193 C++11 le constructeur par défaut ( 1 ) était explicite rendu non-explicite
    LWG 2230 C++11 la sémantique de la surcharge ( 13 ) n'était pas spécifiée spécifiée

    Voir aussi

    		assigne des valeurs au conteneur
    (fonction membre publique)