Namespaces
Variants

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

    From de.cppreference.net

    C++
    Containers library
    std::unordered_multiset
    Member types
    Member functions
    Non-member functions
    Deduction guides (C++17)
    **Änderungen:** - "since C++11" wurde zu "seit C++11" übersetzt - Alle HTML-Tags, Attribute und C++-spezifischen Begriffe (wie `explicit`, `unordered_multiset`, `size_type`, `Hash`, `key_equal`, `Allocator` etc.) wurden unverändert belassen - Die Formatierung und Struktur des HTML-Codes wurde vollständig beibehalten **Erläuterung der Übersetzung:** - Alle HTML-Tags und Attribute wurden unverändert beibehalten - Der C++ Code innerhalb der `` Tags wurde nicht übersetzt - C++-spezifische Begriffe wie `unordered_multiset`, `initializer_list`, `value_type`, etc. wurden nicht übersetzt - Nur der beschreibende Text "(since C++14)" wurde zu "(seit C++14)" übersetzt - Die Formatierung und Struktur der HTML-Elemente bleibt vollständig erhalten (Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)
    (1)
    unordered_multiset ( )
    : unordered_multiset ( size_type ( /* unspecified */ ) ) { }
    		(seit C++11)
    (bis C++20)
    unordered_multiset ( ) ;
    		(seit C++20)
    explicit unordered_multiset ( size_type bucket_count,

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

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

    const Allocator & alloc )

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

    const Hash & hash,
    const Allocator & alloc )

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

    unordered_multiset ( InputIt first, InputIt last,
    size_type bucket_count = /* nicht spezifiziert */ ,
    const Hash & hash = Hash ( ) ,
    const key_equal & equal = key_equal ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(6) (seit 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) (seit 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) (seit C++14)
    unordered_multiset ( const unordered_multiset & other ) ;
    		(9) (seit C++11)
    unordered_multiset ( const unordered_multiset & other, const Allocator & alloc ) ;
    		(10) (seit C++11)
    unordered_multiset ( unordered_multiset && other ) ;
    		(11) (seit C++11)
    unordered_multiset ( unordered_multiset && other, const Allocator & alloc ) ;
    		(12) (seit C++11)
    unordered_multiset ( std:: initializer_list < value_type > init,

    size_type bucket_count = /* nicht spezifiziert */ ,
    const Hash & hash = Hash ( ) ,
    const key_equal & equal = key_equal ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(13) (seit 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) (seit 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) (seit C++14)
    template < container-compatible-range < value_type > R >

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

    const Allocator & alloc = Allocator ( ) ) ;
    		(16) (seit 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) (seit 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) (seit C++23)

    Konstruiert einen neuen Container aus verschiedenen Datenquellen. Verwendet optional die vom Benutzer bereitgestellte bucket_count als minimale Anzahl zu erstellender Buckets, hash als Hash-Funktion, equal als Funktion zum Vergleichen von Schlüsseln und alloc als Allokator.

    1-5) Konstruiert einen leeren Container. Setzt max_load_factor() auf 1.0 . Für den Standardkonstruktor ist die Anzahl der Buckets nicht spezifiziert.
    6-8) Konstruiert den Container mit den Inhalten des Bereichs [ first , last ) . Setzt max_load_factor() auf 1.0 .
    9,10) Kopierkonstruktor. Konstruiert den Container mit der Kopie der Inhalte von other , kopiert ebenfalls den Ladefaktor, das Prädikat und die Hash-Funktion. Falls alloc nicht bereitgestellt wird, wird der Allokator durch Aufruf von std:: allocator_traits < allocator_type > :: select_on_container_copy_construction ( other. get_allocator ( ) ) erhalten.

    Der Template-Parameter Allocator wird nur vom ersten Argument abgeleitet, wenn Klassentemplate-Argumentableitung verwendet wird.

    		(seit C++23)
    11,12) Move-Konstruktor . Konstruiert den Container mit den Inhalten von other unter Verwendung von Move-Semantik. Wenn alloc nicht bereitgestellt wird, wird der Allokator durch Move-Konstruktion vom Allokator von other erhalten.

    Der Template-Parameter Allocator wird nur vom ersten Argument abgeleitet, wenn er in Class Template Argument Deduction verwendet wird.

    		(seit C++23)
    13-15) Initializer-list-Konstruktor . Konstruiert den Container mit den Inhalten der Initialisierungsliste init , identisch mit unordered_multiset ( init. begin ( ) , init. end ( ) ) .
    16-18) Konstruiert den Container mit den Inhalten von rg .

    Inhalt

    Parameter

    alloc - Allokator, der für alle Speicherallokationen dieses Containers verwendet wird
    bucket_count - Minimale Anzahl von Buckets, die bei der Initialisierung verwendet werden. Wenn nicht angegeben, wird ein nicht spezifizierter Standardwert verwendet
    hash - Zu verwendende Hash-Funktion
    equal - Vergleichsfunktion, die für alle Schlüsselvergleiche dieses Containers verwendet wird
    first, last - Das Iteratorpaar, das den Quell- Bereich der zu kopierenden Elemente definiert
    rg - Ein container-kompatibler Bereich , also ein input_range , dessen Elemente in value_type konvertierbar sind
    other - Ein weiterer Container, der als Quelle zur Initialisierung der Elemente des Containers verwendet wird
    init - Initialisierungsliste zur Initialisierung der Elemente des Containers
    Typanforderungen
    -
    InputIt muss die Anforderungen von LegacyInputIterator erfüllen.

    Komplexität

    1-5) Konstante.
    6-8) Durchschnittliche Laufzeit linear (d.h. O(N) , wobei N gleich std:: distance ( first, last ) ist), im schlimmsten Fall quadratisch, d.h. O(N 2 ) .
    9,10) Linear in der Größe von other .
    11,12) Konstant. Wenn alloc angegeben ist und alloc ! = other. get_allocator ( ) , dann linear.
    13-15) Durchschnittlicher Fall O(N) ( N ist std:: size ( init ) ), schlimmster Fall O(N 2 ) .
    16-18) Durchschnittlicher Fall O(N) ( N ist ranges:: distance ( rg ) ), schlechtester Fall O(N 2 ) .

    Ausnahmen

    Aufrufe von Allocator::allocate können eine Ausnahme auslösen.

    Hinweise

    Nach dem Verschiebekonstruktor eines Containers (Überladung (4)), bleiben Referenzen, Zeiger und Iteratoren, die ursprünglich auf Elemente in other verwiesen, gültig, beziehen sich aber nun auf Elemente in *this. Der aktuelle Standard garantiert dies durch die allgemeine Aussage in [container.reqmts]/67, und eine direktere Garantie wird unter LWG issue 2321 erwogen.

    Obwohl formal erst ab C++23 gefordert, haben einige Implementierungen den Template-Parameter Allocator bereits in früheren Modi in nicht-deduzierte Kontexte gesetzt.

    Feature-Test-Makro Wert Std -Merkmal
    __cpp_lib_containers_ranges 202202L (C++23) Ranges-bewusste Konstruktion und Einfügung; Überladungen (16-18)

    Beispiel

    Dieser Abschnitt ist unvollständig
    Grund: Kein Beispiel

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
    LWG 2193 C++11 der Standardkonstruktor ( 1 ) war explicit als non-explicit festgelegt
    LWG 2230 C++11 die Semantik von Überladung ( 13 ) war nicht spezifiziert spezifiziert

    Siehe auch

    		weist dem Container Werte zu
    (öffentliche Elementfunktion)