unordered_multimap-klasse

In de klassesjabloon wordt een object beschreven dat een reeks elementen van het type std::pair<const Key, Ty>bepaalt. De reeks is zwak gerangschikt door een hash-functie, die de reeks partitioneert in een geordende set subsequences die buckets worden genoemd. Binnen elke bucket bepaalt een vergelijkingsfunctie of een paar elementen gelijkwaardige volgorde heeft. Elk element slaat twee objecten, een sorteersleutel en een waarde op. De reeks wordt weergegeven op een manier die het opzoeken, invoegen en verwijderen van een willekeurig element mogelijk maakt met een aantal bewerkingen die onafhankelijk kunnen zijn van het aantal elementen in de reeks (constante tijd), ten minste wanneer alle buckets ongeveer even lang zijn. Als alle elementen zich in één bucket bevinden, is het aantal bewerkingen evenredig met het aantal elementen in de reeks (lineaire tijd). Als u een element invoegt, worden er bovendien geen iterators meer gebruikt en worden alleen de iterators die naar het verwijderde element verwijzen, ongeldig.

Syntaxis

template <class Key,
    class Ty,
    class Hash = std::hash<Key>,
    class Pred = std::equal_to<Key>,
    class Alloc = std::allocator<Key>>
class unordered_multimap;

Parameterwaarden

Sleutel
Het sleuteltype.

Ty
Het toegewezen type.

Hekje
Het objecttype hashfunctie.

Pred
Het objecttype gelijkheidsvergelijkingsfunctie.

Alloc
De allocatorklasse.

Leden

Opmerkingen

Het object rangorde de volgorde die het beheert door twee opgeslagen objecten aan te roepen, een vergelijkingsfunctieobject van het type unordered_multimap::key_equal en een hash-functieobject van het type unordered_multimap::hasher. U opent het eerste opgeslagen object door de lidfunctie aan te roepen unordered_multimap::key_eq(); en u opent het tweede opgeslagen object door de lidfunctie aan te roepen unordered_multimap::hash_function(). Met name voor alle waarden X en Y van het type Keyretourneert de aanroep key_eq()(X, Y) alleen waar als de twee argumentwaarden gelijkwaardige volgorde hebben; de aanroep hash_function()(keyval) resulteert in een verdeling van de waarden van het type size_t. In tegenstelling tot klassesjabloon unordered_mapzorgt een object van het type unordered_multimap er niet voor dat key_eq()(X, Y) deze altijd onwaar is voor twee elementen van de gecontroleerde reeks. (Sleutels hoeven niet uniek te zijn.)

Het object slaat ook een maximale belastingsfactor op, waarmee het maximale gewenste gemiddelde aantal elementen per bucket wordt opgegeven. Als het invoegen van een element ervoor zorgt dat unordered_multimap::load_factor() de maximale belastingsfactor overschrijdt, verhoogt de container het aantal buckets en herbouwt de hash-tabel indien nodig.

De werkelijke volgorde van elementen in de gecontroleerde volgorde is afhankelijk van de hash-functie, de vergelijkingsfunctie, de volgorde van invoeging, de maximale laadfactor en het huidige aantal buckets. U kunt in het algemeen de volgorde van elementen in de gecontroleerde volgorde niet voorspellen. U kunt er echter altijd zeker van zijn dat elke subset van elementen met gelijkwaardige volgorde grenzen aan de gecontroleerde volgorde.

Het object wijst en maakt opslag vrij voor de volgorde die het beheert via een opgeslagen allocatorobject van het type unordered_multimap::allocator_type. Een dergelijk allocatorobject moet dezelfde externe interface hebben als een object van het type allocator. Houd er rekening mee dat het opgeslagen allocatorobject niet wordt gekopieerd wanneer het containerobject wordt toegewezen.

Behoeften

Rubriek:<unordered_map>

naamruimte: std

unordered_multimap::allocator_type

Het type allocator voor het beheren van opslag.

typedef Alloc allocator_type;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Alloc.

Voorbeeld

// std__unordered_map__unordered_multimap_allocator_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
    {
    Mymap c1;

    Mymap::allocator_type al = c1.get_allocator();
    std::cout << "al == std::allocator() is "
        << std::boolalpha << (al == Myalloc()) << std::endl;

    return (0);
    }

al == std::allocator() is true

unordered_multimap::begin

Hiermee wordt het begin van de gecontroleerde reeks of een bucket aangeduid.

iterator begin();

const_iterator begin() const;

local_iterator begin(size_type nbucket);

const_local_iterator begin(size_type nbucket) const;

Parameterwaarden

nbucket
Het bucketnummer.

Opmerkingen

De eerste twee lidfuncties retourneren een doorstuur iterator die verwijst naar het eerste element van de reeks (of net voorbij het einde van een lege reeks). De laatste twee lidfuncties retourneren een doorstuur iterator die verwijst naar het eerste element van bucket nbucket (of net voorbij het einde van een lege bucket).

Voorbeeld

// std__unordered_map__unordered_multimap_begin.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect first two items " [c 3] [b 2]"
    Mymap::iterator it2 = c1.begin();
    std::cout << " [" << it2->first << ", " << it2->second << "]";
    ++it2;
    std::cout << " [" << it2->first << ", " << it2->second << "]";
    std::cout << std::endl;

// inspect bucket containing 'a'
    Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << " [" << lit->first << ", " << lit->second << "]";

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[c, 3] [b, 2]
[a, 1]

unordered_multimap::bucket

Hiermee wordt het bucketnummer voor een sleutelwaarde opgehaald.

size_type bucket(const Key& keyval) const;

Parameterwaarden

sleutelval
De sleutelwaarde die moet worden toegewezen.

Opmerkingen

De lidfunctie retourneert het bucketnummer dat momenteel overeenkomt met de sleutelwaardesleutelval.

Voorbeeld

// std__unordered_map__unordered_multimap_bucket.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// display buckets for keys
    Mymap::size_type bs = c1.bucket('a');
    std::cout << "bucket('a') == " << bs << std::endl;
    std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
        << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
bucket('a') == 7
bucket_size(7) == 1

unordered_multimap::bucket_count

Hiermee haalt u het aantal buckets op.

size_type bucket_count() const;

Opmerkingen

De lidfunctie retourneert het huidige aantal buckets.

Voorbeeld

// std__unordered_map__unordered_multimap_bucket_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

// change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

// rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multimap::bucket_size

Hiermee wordt de grootte van een bucket opgehaald

size_type bucket_size(size_type nbucket) const;

Parameterwaarden

nbucket
Het bucketnummer.

Opmerkingen

De lidfuncties retourneren de grootte van bucketnummer nbucket.

Voorbeeld

// std__unordered_map__unordered_multimap_bucket_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// display buckets for keys
    Mymap::size_type bs = c1.bucket('a');
    std::cout << "bucket('a') == " << bs << std::endl;
    std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
        << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
bucket('a') == 7
bucket_size(7) == 1

unordered_multimap::cbegin

Retourneert een const iterator die het eerste element in het bereik adresseert.

const_iterator cbegin() const;

Retourwaarde

Een const iterator voor forward-access die verwijst naar het eerste element van het bereik, of de locatie vlak voorbij het einde van een leeg bereik (voor een leeg bereik, cbegin() == cend()).

Opmerkingen

Met de retourwaarde van cbeginkan de elementen in het bereik niet worden gewijzigd.

U kunt deze lidfunctie gebruiken in plaats van de functie begin() lid om te garanderen dat de retourwaarde const_iteratoris. Normaal gesproken wordt deze gebruikt in combinatie met het trefwoord voor automatische type aftrek, zoals wordt weergegeven in het volgende voorbeeld. In het voorbeeld kunt u overwegen Container te zijn als een wijzigbare container (niet-const) van elk type dat ondersteuning biedt voor begin() en cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

unordered_multimap::cend

Retourneert een const iterator die de locatie net voorbij het laatste element in een bereik adresseert.

const_iterator cend() const;

Retourwaarde

Een const iterator voor doorgestuurde toegang die net buiten het einde van het bereik wijst.

Opmerkingen

cend wordt gebruikt om te testen of een iterator het einde van het bereik heeft doorstaan.

U kunt deze lidfunctie gebruiken in plaats van de functie end() lid om te garanderen dat de retourwaarde const_iteratoris. Normaal gesproken wordt deze gebruikt in combinatie met het trefwoord voor automatische type aftrek, zoals wordt weergegeven in het volgende voorbeeld. In het voorbeeld kunt u overwegen Container te zijn als een wijzigbare container (niet-const) van elk type dat ondersteuning biedt voor end() en cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

De waarde die wordt geretourneerd door cend mag niet worden afgetrokken.

unordered_multimap::clear

Hiermee verwijdert u alle elementen.

void clear();

Opmerkingen

De lidfunctie roept unordered_multimap::gum(unordered_multimap:begin(),unordered_multimap::end()) aan.

Voorbeeld

// std__unordered_map__unordered_multimap_clear.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert(Mymap::value_type('d', 4));
    c1.insert(Mymap::value_type('e', 5));

// display contents " [e 5] [d 4]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
size == 0
empty() == true

[e, 5] [d, 4]
size == 2
empty() == false

unordered_multimap::const_iterator

Het type van een constante iterator voor de gecontroleerde reeks.

typedef T1 const_iterator;

Opmerkingen

Het type beschrijft een object dat kan fungeren als een constante doorstuurserver voor de gecontroleerde reeks. Het wordt hier beschreven als synoniem voor het door de implementatie gedefinieerde type T1.

Voorbeeld

// std__unordered_map__unordered_multimap_const_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]

unordered_multimap::const_local_iterator

Het type van een constante bucket-iterator voor de gecontroleerde reeks.

typedef T5 const_local_iterator;

Opmerkingen

Het type beschrijft een object dat kan fungeren als een constante doorstuurserver voor een bucket. Het wordt hier beschreven als synoniem voor het door de implementatie gedefinieerde type T5.

Voorbeeld

// std__unordered_map__unordered_multimap_const_local_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect bucket containing 'a'
    Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << " [" << lit->first << ", " << lit->second << "]";

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[a, 1]

unordered_multimap::const_pointer

Het type constante aanwijzer naar een element.

typedef Alloc::const_pointer const_pointer;

Opmerkingen

Het type beschrijft een object dat kan fungeren als een constante aanwijzer naar een element van de gecontroleerde reeks.

Voorbeeld

// std__unordered_map__unordered_multimap_const_pointer.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Mymap::const_pointer p = &*it;
        std::cout << " [" << p->first << ", " << p->second << "]";
        }
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]

unordered_multimap::const_reference

Het type constante verwijzing naar een element.

typedef Alloc::const_reference const_reference;

Opmerkingen

Het type beschrijft een object dat kan fungeren als een constante verwijzing naar een element van de gecontroleerde reeks.

Voorbeeld

// std__unordered_map__unordered_multimap_const_reference.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Mymap::const_reference ref = *it;
        std::cout << " [" << ref.first << ", " << ref.second << "]";
        }
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]

unordered_multimap::contains

Controleert of er een element is met de opgegeven sleutel in de unordered_multimap.

bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;

Parameterwaarden

K
Het type sleutel.

sleutel
De sleutelwaarde van het element waarnaar moet worden gezocht.

Retourwaarde

true als het element in de container is gevonden; false anders.

Opmerkingen

contains() is nieuw in C++20. Als u deze wilt gebruiken, geeft u de optie /std:c++20 of hoger compiler op.

template<class K> bool contains(const K& key) const neemt alleen deel aan overbelastingsresolutie als key_compare transparant is.

Voorbeeld

// Requires /std:c++20 or later
#include <unordered_map>
#include <iostream>

int main()
{
    std::unordered_multimap<int, bool> theUnorderedMultimap = {{0, false}, {1,true}};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << theUnorderedMultimap.contains(1) << '\n';
    std::cout << theUnorderedMultimap.contains(2) << '\n';

    return 0;
}

true
false

unordered_multimap::count

Hiermee wordt het aantal elementen gevonden dat overeenkomt met een opgegeven sleutel.

size_type count(const Key& keyval) const;

Parameterwaarden

sleutelval
Sleutelwaarde om naar te zoeken.

Opmerkingen

De lidfunctie retourneert het aantal elementen in het bereik dat is gescheiden door unordered_multimap::equal_range(keyval).

Voorbeeld

// std__unordered_map__unordered_multimap_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    std::cout << "count('A') == " << c1.count('A') << std::endl;
    std::cout << "count('b') == " << c1.count('b') << std::endl;
    std::cout << "count('C') == " << c1.count('C') << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
count('A') == 0
count('b') == 1
count('C') == 0

unordered_multimap::d deductietype

Het type ondertekende afstand tussen twee elementen.

typedef T3 difference_type;

Opmerkingen

Het ondertekende geheel getaltype beschrijft een object dat het verschil kan vertegenwoordigen tussen de adressen van twee elementen in de gecontroleerde reeks. Het wordt hier beschreven als synoniem voor het door de implementatie gedefinieerde type T3.

Voorbeeld

// std__unordered_map__unordered_multimap_difference_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// compute positive difference
    Mymap::difference_type diff = 0;
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        ++diff;
    std::cout << "end()-begin() == " << diff << std::endl;

// compute negative difference
    diff = 0;
    for (Mymap::const_iterator it = c1.end();
        it != c1.begin(); --it)
        --diff;
    std::cout << "begin()-end() == " << diff << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
end()-begin() == 3
begin()-end() == -3

unordered_multimap::emplace

Hiermee voegt u een element in dat is samengesteld (er worden geen kopieer- of verplaatsingsbewerkingen uitgevoerd), met een plaatsingshint.

template <class... Args>
iterator emplace(Args&&... args);

Parameterwaarden

args
De argumenten die zijn doorgestuurd om een element te maken dat moet worden ingevoegd in de unordered_multimap.

Retourwaarde

Een iterator voor het zojuist ingevoegde element.

Opmerkingen

Er worden geen verwijzingen naar containerelementen ongeldig gemaakt door deze functie, maar mogelijk worden alle iterators ongeldig voor de container.

Het value_type van een element is een paar, zodat de waarde van een element een geordende combinatie is met het eerste onderdeel dat gelijk is aan de sleutelwaarde en het tweede onderdeel gelijk is aan de gegevenswaarde van het element.

Als tijdens de invoeging een uitzondering wordt gegenereerd, maar niet voorkomt in de hash-functie van de container, wordt de container niet gewijzigd. Als de uitzondering wordt gegenereerd in de hash-functie, is het resultaat niet gedefinieerd.

Zie multimap::emplace voor een codevoorbeeld.

unordered_multimap::emplace_hint

Hiermee voegt u een element in dat is samengesteld (er worden geen kopieer- of verplaatsingsbewerkingen uitgevoerd), met een plaatsingshint.

template <class... Args>
iterator emplace_hint(
    const_iterator where,
    Args&&... args);

Parameterwaarden

args
De argumenten die worden doorgestuurd om een element te maken dat in de niet-geordende volgorde moet worden ingevoegd.

waar
Een hint met betrekking tot de plaats waar moet worden gezocht naar het juiste invoegpunt.

Retourwaarde

Een iterator voor het zojuist ingevoegde element.

Opmerkingen

Er worden geen verwijzingen naar containerelementen ongeldig gemaakt door deze functie, maar mogelijk worden alle iterators ongeldig voor de container.

Als tijdens de invoeging een uitzondering wordt gegenereerd, maar niet voorkomt in de hash-functie van de container, wordt de container niet gewijzigd. Als de uitzondering wordt gegenereerd in de hash-functie, is het resultaat niet gedefinieerd.

Het value_type van een element is een paar, zodat de waarde van een element een geordende combinatie is met het eerste onderdeel dat gelijk is aan de sleutelwaarde en het tweede onderdeel gelijk is aan de gegevenswaarde van het element.

Zie map::emplace_hint voor een codevoorbeeld.

unordered_multimap::empty

Test of er geen elementen aanwezig zijn.

bool empty() const;

Opmerkingen

De lidfunctie retourneert waar voor een lege beheerde reeks.

Voorbeeld

// std__unordered_map__unordered_multimap_empty.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert(Mymap::value_type('d', 4));
    c1.insert(Mymap::value_type('e', 5));

// display contents " [e 5] [d 4]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
size == 0
empty() == true

[e, 5] [d, 4]
size == 2
empty() == false

unordered_multimap::end

Geeft het einde van de gecontroleerde reeks aan.

iterator end();

const_iterator end() const;

local_iterator end(size_type nbucket);

const_local_iterator end(size_type nbucket) const;

Parameterwaarden

nbucket
Het bucketnummer.

Opmerkingen

De eerste twee lidfuncties retourneren een doorstuur iterator die net buiten het einde van de reeks wijst. De laatste twee lidfuncties retourneren een doorstuur iterator die net voorbij het einde van bucket nbucket wijst.

Voorbeeld

// std__unordered_map__unordered_multimap_end.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect last two items " [a 1] [b 2]"
    Mymap::iterator it2 = c1.end();
    --it2;
    std::cout << " [" << it2->first << ", " << it2->second << "]";
    --it2;
    std::cout << " [" << it2->first << ", " << it2->second << "]";
    std::cout << std::endl;

// inspect bucket containing 'a'
    Mymap::const_local_iterator lit = c1.end(c1.bucket('a'));
    --lit;
    std::cout << " [" << lit->first << ", " << lit->second << "]";

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[a, 1] [b, 2]
[a, 1]

unordered_multimap::equal_range

Hiermee vindt u een bereik dat overeenkomt met een opgegeven sleutel.

std::pair<iterator, iterator>
    equal_range(const Key& keyval);

std::pair<const_iterator, const_iterator>
    equal_range(const Key& keyval) const;

Parameterwaarden

sleutelval
Sleutelwaarde om naar te zoeken.

Opmerkingen

De lidfunctie retourneert een paar iterators X , zodat [X.first, X.second) alleen die elementen van de gecontroleerde reeks worden gescheiden die equivalente volgorde hebben met keyval. Als er geen dergelijke elementen bestaan, worden beide iterators end().

Voorbeeld

// std__unordered_map__unordered_multimap_equal_range.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// display results of failed search
    std::pair<Mymap::iterator, Mymap::iterator> pair1 =
        c1.equal_range('x');
    std::cout << "equal_range('x'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << " [" << pair1.first->first
            << ", " << pair1.first->second << "]";
    std::cout << std::endl;

// display results of successful search
    pair1 = c1.equal_range('b');
    std::cout << "equal_range('b'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << " [" << pair1.first->first
            << ", " << pair1.first->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
equal_range('x'):
equal_range('b'): [b, 2]

unordered_multimap::wissen

Hiermee verwijdert u een element of een reeks elementen in een unordered_multimap uit de opgegeven posities of verwijdert u elementen die overeenkomen met een opgegeven sleutel.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parameterwaarden

Waar
Positie van het element dat moet worden verwijderd.

Eerste
Positie van het eerste element dat moet worden verwijderd.

laatste
Plaats net buiten het laatste element dat moet worden verwijderd.

Sleutel
De sleutelwaarde van de elementen die moeten worden verwijderd.

Retourwaarde

Voor de eerste twee lidfuncties, een bidirectionele iterator die het eerste element aanwijst dat buiten alle verwijderde elementen blijft, of een element dat het einde van de kaart is als er geen dergelijk element bestaat.

Voor de functie derde lid wordt het aantal elementen geretourneerd dat uit de unordered_multimap is verwijderd.

Opmerkingen

Zie map::erase voor een codevoorbeeld.

unordered_multimap::find

Hiermee zoekt u een element dat overeenkomt met een opgegeven sleutel.

const_iterator find(const Key& keyval) const;

Parameterwaarden

sleutelval
Sleutelwaarde om naar te zoeken.

Opmerkingen

De lidfunctie retourneert unordered_multimap::equal_range(keyval).first.

Voorbeeld

// std__unordered_map__unordered_multimap_find.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// try to find and fail
    std::cout << "find('A') == "
        << std::boolalpha << (c1.find('A') != c1.end()) << std::endl;

// try to find and succeed
    Mymap::iterator it = c1.find('b');
    std::cout << "find('b') == "
        << std::boolalpha << (it != c1.end())
        << ": [" << it->first << ", " << it->second << "]" << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
find('A') == false
find('b') == true: [b, 2]

unordered_multimap::get_allocator

Hiermee haalt u het opgeslagen allocatorobject op.

Alloc get_allocator() const;

Opmerkingen

De lidfunctie retourneert het opgeslagen allocator-object.

Voorbeeld

// std__unordered_map__unordered_multimap_get_allocator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
    {
    Mymap c1;

    Mymap::allocator_type al = c1.get_allocator();
    std::cout << "al == std::allocator() is "
        << std::boolalpha << (al == Myalloc()) << std::endl;

    return (0);
    }

al == std::allocator() is true

unordered_multimap::hash_function

Hiermee haalt u het opgeslagen hash-functieobject op.

Hash hash_function() const;

Opmerkingen

De lidfunctie retourneert het opgeslagen hash-functieobject.

Voorbeeld

// std__unordered_map__unordered_multimap_hash_function.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    Mymap::hasher hfn = c1.hash_function();
    std::cout << "hfn('a') == " << hfn('a') << std::endl;
    std::cout << "hfn('b') == " << hfn('b') << std::endl;

    return (0);
    }

hfn('a') == 1630279
hfn('b') == 1647086

unordered_multimap::hasher

Het type hash-functie.

typedef Hash hasher;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Hash.

Voorbeeld

// std__unordered_map__unordered_multimap_hasher.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    Mymap::hasher hfn = c1.hash_function();
    std::cout << "hfn('a') == " << hfn('a') << std::endl;
    std::cout << "hfn('b') == " << hfn('b') << std::endl;

    return (0);
    }

hfn('a') == 1630279
hfn('b') == 1647086

unordered_multimap::insert

Hiermee voegt u een element of een reeks elementen in een unordered_multimap in.

// (1) single element
pair<iterator, bool> insert(
    const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
    ValTy&& Val);

// (3) single element with hint
iterator insert(
    const_iterator Where,
    const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

// (5) range
template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

// (6) initializer list
void insert(
    initializer_list<value_type>
IList);

Parameterwaarden

Val
De waarde van een element dat moet worden ingevoegd in de unordered_multimap.

Waar
De plaats om te beginnen met zoeken naar het juiste invoegpunt.

ValTy
Sjabloonparameter die het argumenttype aangeeft dat de unordered_multimap kan gebruiken om een element van value_type samen te stellen en perfect-forwards Val als argument.

Eerste
De positie van het eerste element dat moet worden gekopieerd.

laatste
De positie net voorbij het laatste element dat moet worden gekopieerd.

InputIterator
Argument sjabloonfunctie die voldoet aan de vereisten van een invoer-iterator die verwijst naar elementen van een type dat kan worden gebruikt om value_type objecten te maken.

IList
De initializer_list waaruit u de elementen wilt kopiëren.

Retourwaarde

Met de functies voor lid met één element( 1) en (2) wordt een iterator geretourneerd naar de positie waar het nieuwe element in de unordered_multimap is ingevoegd.

De functies met één element-met-hintlid, (3) en (4), retourneren een iterator die verwijst naar de positie waar het nieuwe element is ingevoegd in de unordered_multimap.

Opmerkingen

Er worden geen verwijzingen of verwijzingen ongeldig gemaakt door deze functie, maar mogelijk worden alle iterators naar de container ongeldig gemaakt.

Als tijdens het invoegen van slechts één element een uitzondering wordt gegenereerd maar niet voorkomt in de hash-functie van de container, wordt de status van de container niet gewijzigd. Als de uitzondering wordt gegenereerd in de hash-functie, is het resultaat niet gedefinieerd. Als er tijdens het invoegen van meerdere elementen een uitzondering wordt gegenereerd, blijft de container een niet-opgegeven maar geldige status behouden.

De value_type van een container is een typedef die deel uitmaakt van de container en voor toewijzingmap<K, V>::value_type.pair<const K, V> De waarde van een element is een geordende paar waarin het eerste onderdeel gelijk is aan de sleutelwaarde en het tweede onderdeel gelijk is aan de gegevenswaarde van het element.

Met de functie bereiklid (5) wordt de reeks elementwaarden ingevoegd in een unordered_multimap die overeenkomt met elk element dat is geadresseerd door een iterator in het bereik [First, Last); Daarom wordt Last niet ingevoegd. De functie end() containerlid verwijst naar de positie vlak na het laatste element in de container, bijvoorbeeld de instructie m.insert(v.begin(), v.end()); voegt alle elementen van v in m.

De functie initialisatielijstlid (6) gebruikt een initializer_list om elementen naar de unordered_multimap te kopiëren.

Zie unordered_multimap::emplace en unordered_multimap::emplace_hint voor het invoegen van een element dat op zijn plaats is gemaakt, dat wil gezegd, geen kopieer- of verplaatsingsbewerkingen worden uitgevoerd.

Zie multimap::insert voor een codevoorbeeld.

unordered_multimap::iterator

Het type iterator voor de gecontroleerde reeks.

typedef T0 iterator;

Opmerkingen

Het type beschrijft een object dat kan fungeren als een doorstuur iterator voor de gecontroleerde reeks. Het wordt hier beschreven als synoniem voor het door de implementatie gedefinieerde type T0.

Voorbeeld

// std__unordered_map__unordered_multimap_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]

unordered_multimap::key_eq

Hiermee haalt u het opgeslagen vergelijkingsfunctieobject op.

Pred key_eq() const;

Opmerkingen

De lidfunctie retourneert het opgeslagen vergelijkingsfunctieobject.

Voorbeeld

// std__unordered_map__unordered_multimap_key_eq.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    Mymap::key_equal cmpfn = c1.key_eq();
    std::cout << "cmpfn('a', 'a') == "
        << std::boolalpha << cmpfn('a', 'a') << std::endl;
    std::cout << "cmpfn('a', 'b') == "
        << std::boolalpha << cmpfn('a', 'b') << std::endl;

    return (0);
    }

cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

unordered_multimap::key_equal

Het type vergelijkingsfunctie.

typedef Pred key_equal;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Pred.

Voorbeeld

// std__unordered_map__unordered_multimap_key_equal.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    Mymap::key_equal cmpfn = c1.key_eq();
    std::cout << "cmpfn('a', 'a') == "
        << std::boolalpha << cmpfn('a', 'a') << std::endl;
    std::cout << "cmpfn('a', 'b') == "
        << std::boolalpha << cmpfn('a', 'b') << std::endl;

    return (0);
    }

cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

unordered_multimap::key_type

Het type bestelsleutel.

typedef Key key_type;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Key.

Voorbeeld

// std__unordered_map__unordered_multimap_key_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// add a value and reinspect
    Mymap::key_type key = 'd';
    Mymap::mapped_type mapped = 4;
    Mymap::value_type val = Mymap::value_type(key, mapped);
    c1.insert(val);

    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]

unordered_multimap::load_factor

Telt de gemiddelde elementen per bucket.

float load_factor() const;

Opmerkingen

De lidfunctie retourneert (float)unordered_multimap::size() / (float)unordered_multimap::bucket_count(), het gemiddelde aantal elementen per bucket.

Voorbeeld

// std__unordered_map__unordered_multimap_load_factor.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

// change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

// rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
    }

unordered_multimap::local_iterator

Het type bucket-iterator.

typedef T4 local_iterator;

Opmerkingen

Het type beschrijft een object dat kan fungeren als een doorstuurserver voor een bucket. Het wordt hier beschreven als synoniem voor het door de implementatie gedefinieerde type T4.

Voorbeeld

// std__unordered_map__unordered_multimap_local_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect bucket containing 'a'
    Mymap::local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << " [" << lit->first << ", " << lit->second << "]";

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[a, 1]

unordered_multimap::mapped_type

Het type toegewezen waarde dat aan elke sleutel is gekoppeld.

typedef Ty mapped_type;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Ty.

Voorbeeld

// std__unordered_map__unordered_multimap_mapped_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// add a value and reinspect
    Mymap::key_type key = 'd';
    Mymap::mapped_type mapped = 4;
    Mymap::value_type val = Mymap::value_type(key, mapped);
    c1.insert(val);

    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]

unordered_multimap::max_bucket_count

Hiermee haalt u het maximum aantal buckets op.

size_type max_bucket_count() const;

Opmerkingen

De lidfunctie retourneert het maximum aantal buckets dat momenteel is toegestaan.

Voorbeeld

// std__unordered_map__unordered_multimap_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

// change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

// rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multimap::max_load_factor

Hiermee worden de maximumelementen per bucket opgehaald of ingesteld.

float max_load_factor() const;

void max_load_factor(float factor);

Parameterwaarden

factor
De nieuwe maximale belastingsfactor.

Opmerkingen

De eerste lidfunctie retourneert de opgeslagen maximale belastingsfactor. De tweede lidfunctie vervangt de opgeslagen maximale belastingsfactor door factor.

Voorbeeld

// std__unordered_map__unordered_multimap_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

// change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

// rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multimap::max_size

Hiermee haalt u de maximale grootte van de gecontroleerde reeks op.

size_type max_size() const;

Opmerkingen

De lidfunctie retourneert de lengte van de langste reeks die het object kan beheren.

Voorbeeld

// std__unordered_map__unordered_multimap_max_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    std::cout << "max_size() == " << c1.max_size() << std::endl;

    return (0);
    }

max_size() == 536870911

unordered_multimap::operator=

Kopieert een hash-tabel.

unordered_multimap& operator=(const unordered_multimap& right);

unordered_multimap& operator=(unordered_multimap&& right);

Parameterwaarden

rechts
De unordered_multimap worden gekopieerd naar de unordered_multimap.

Opmerkingen

Nadat bestaande elementen in een unordered_multimap zijn verwijderd, operator= kopieert of verplaatst u de inhoud van rechts naar de unordered_multimap.

Voorbeeld

// unordered_multimap_operator_as.cpp
// compile with: /EHsc
#include <unordered_multimap>
#include <iostream>

int main( )
   {
   using namespace std;
   unordered_multimap<int, int> v1, v2, v3;
   unordered_multimap<int, int>::iterator iter;

   v1.insert(pair<int, int>(1, 10));

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << iter->second << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter->second << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter->second << " ";
   cout << endl;
   }

unordered_multimap::p ointer

Het type aanwijzer naar een element.

typedef Alloc::pointer pointer;

Opmerkingen

Het type beschrijft een object dat kan fungeren als een aanwijzer naar een element van de gecontroleerde reeks.

Voorbeeld

// std__unordered_map__unordered_multimap_pointer.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Mymap::pointer p = &*it;
        std::cout << " [" << p->first << ", " << p->second << "]";
        }
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]

unordered_multimap::reference

Het type verwijzing naar een element.

typedef Alloc::reference reference;

Opmerkingen

Het type beschrijft een object dat kan fungeren als een verwijzing naar een element van de gecontroleerde reeks.

Voorbeeld

// std__unordered_map__unordered_multimap_reference.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Mymap::reference ref = *it;
        std::cout << " [" << ref.first << ", " << ref.second << "]";
        }
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]

unordered_multimap::rehash

Hiermee wordt de hash-tabel opnieuw opgebouwd.

void rehash(size_type nbuckets);

Parameterwaarden

nbuckets
Het aangevraagde aantal buckets.

Opmerkingen

Met de lidfunctie wordt het aantal buckets gewijzigd in ten minste nbuckets en wordt de hash-tabel zo nodig opnieuw opgebouwd.

Voorbeeld

// std__unordered_map__unordered_multimap_rehash.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

// change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

// rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_load_factor() == 0.1

unordered_multimap::size

Telt het aantal elementen.

size_type size() const;

Opmerkingen

De lidfunctie retourneert de lengte van de gecontroleerde reeks.

Voorbeeld

// std__unordered_map__unordered_multimap_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert(Mymap::value_type('d', 4));
    c1.insert(Mymap::value_type('e', 5));

// display contents " [e 5] [d 4]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
size == 0
empty() == true

[e, 5] [d, 4]
size == 2
empty() == false

unordered_multimap::size_type

Het type niet-ondertekende afstand tussen twee elementen.

typedef T2 size_type;

Opmerkingen

Het niet-ondertekende gehele getaltype beschrijft een object dat de lengte van een gecontroleerde reeks kan vertegenwoordigen. Het wordt hier beschreven als synoniem voor het door de implementatie gedefinieerde type T2.

Voorbeeld

// std__unordered_map__unordered_multimap_size_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;
    Mymap::size_type sz = c1.size();

    std::cout << "size == " << sz << std::endl;

    return (0);
    }

size == 0

unordered_multimap::wisselen

Hiermee wordt de inhoud van twee containers gewisseld.

void swap(unordered_multimap& right);

Parameterwaarden

rechts
De container waarmee moet worden gewisseld.

Opmerkingen

De lidfunctie wisselt de gecontroleerde reeksen tussen *this en rechter. Als unordered_multimap::get_allocator() == right.get_allocator(), wordt dit in constante tijd gedaan, wordt er alleen een uitzondering gegenereerd als gevolg van het kopiëren van het opgeslagen kenmerkobject van het type Tr, en het ongeldig maakt geen verwijzingen, aanwijzers of iterators die elementen in de twee gecontroleerde sequenties aanwijzen. Anders worden een aantal elementtoewijzingen en constructor-aanroepen uitgevoerd die evenredig zijn met het aantal elementen in de twee gecontroleerde reeksen.

Voorbeeld

// std__unordered_map__unordered_multimap_swap.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    Mymap c2;

    c2.insert(Mymap::value_type('d', 4));
    c2.insert(Mymap::value_type('e', 5));
    c2.insert(Mymap::value_type('f', 6));

    c1.swap(c2);

// display contents " [f 6] [e 5] [d 4]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    swap(c1, c2);

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[f, 6] [e, 5] [d, 4]
[c, 3] [b, 2] [a, 1]

unordered_multimap::unordered_multimap

Maakt een containerobject.

unordered_multimap(
    const unordered_multimap& Right);

explicit unordered_multimap(
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Pred(),
    const Allocator& Al = Alloc());

unordered_multimap(
    unordered_multimap&& Right);

unordered_multimap(
    initializer_list<Type> IList);

unordered_multimap(
    initializer_list<Type> IList,
    size_type Bucket_count);

unordered_multimap(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash);

unordered_multimap(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    const Key& Key);

unordered_multimap(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    const Key& Key,
    const Allocator& Al);

template <class InputIterator>
unordered_multimap(
    InputIterator first,
    InputIterator last,
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Pred(),
    const Allocator& Al = Alloc());

Parameterwaarden

InputIterator
Het type iterator.

Al
Het allocatorobject dat moet worden opgeslagen.

Comp
Het vergelijkingsfunctieobject dat moet worden opgeslagen.

Hekje
Het hash-functieobject dat moet worden opgeslagen.

Bucket_count
Het minimum aantal buckets.

Rechts
De container die moet worden gekopieerd.

IList
De initializer_list waaruit de elementen moeten worden gekopieerd.

Opmerkingen

De eerste constructor geeft een kopie op van de reeks die wordt beheerd door Right. De tweede constructor geeft een lege gecontroleerde reeks aan. De derde constructor. geeft een kopie van de reeks op door naar rechts te gaan. De vierde, vijfde, zesde, zevende en achtste constructors gebruiken een initializer_list voor de leden. De negende constructor voegt de reeks elementwaarden [First, Last)in.

Alle constructors initialiseren ook verschillende opgeslagen waarden. Voor de kopieerconstructor worden de waarden opgehaald van Rechts. Anders:

Het minimum aantal buckets is het argument Bucket_count, indien aanwezig; anders is het een standaardwaarde die hier wordt beschreven als de door de implementatie gedefinieerde waarde N0.

Het hash-functieobject is het argument Hash, indien aanwezig; anders is Hash()het .

Het vergelijkingsfunctieobject is het argument Comp, indien aanwezig; anders is Pred()het .

Het allocatorobject is het argument Al, indien aanwezig; anders is Alloc()het .

Voorbeeld

// std__unordered_map__unordered_multimap_construct.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

using namespace std;

using  Mymap = unordered_multimap<char, int> ;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    Mymap c2(8,
        hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >());

    c2.insert(Mymap::value_type('d', 4));
    c2.insert(Mymap::value_type('e', 5));
    c2.insert(Mymap::value_type('f', 6));

    // display contents " [f 6] [e 5] [d 4]"
    for (const auto& c : c2) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    Mymap c3(c1.begin(),
        c1.end(),
        8,
        hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >());

    // display contents " [c 3] [b 2] [a 1]"
    for (const auto& c : c3) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    Mymap c4(move(c3));

    // display contents " [c 3] [b 2] [a 1]"
    for (const auto& c : c4) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Construct with an initializer_list
    unordered_multimap<int, char> c5({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } });
    for (const auto& c : c5) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size
    unordered_multimap<int, char> c6({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } }, 4);
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size and hash
    unordered_multimap<int, char, hash<char>> c7(
        { { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
        4,
        hash<char>()
    );

    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size, hash, and key_equal
    unordered_multimap<int, char, hash<char>, equal_to<char>> c8(
        { { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
        4,
        hash<char>(),
        equal_to<char>()
    );

    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size, hash, key_equal, and allocator
    unordered_multimap<int, char, hash<char>, equal_to<char>> c9(
        { { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
        4,
        hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >()
    );

    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;
}

[a, 1] [b, 2] [c, 3] [d, 4] [e, 5] [f, 6] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [5, g] [6, h] [7, i] [8, j] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [c, 3] [b, 2] [a, 1]
[f, 6] [e, 5] [d, 4]
[c, 3] [b, 2] [a, 1]
[c, 3] [b, 2] [a, 1]

unordered_multimap::value_type

Het type element.

typedef std::pair<const Key, Ty> value_type;

Opmerkingen

Het type beschrijft een element van de gecontroleerde reeks.

Voorbeeld

// std__unordered_map__unordered_multimap_value_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// add a value and reinspect
    Mymap::key_type key = 'd';
    Mymap::mapped_type mapped = 4;
    Mymap::value_type val = Mymap::value_type(key, mapped);
    c1.insert(val);

    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]

Zie ook

<unordered_map>
Containers
Thread Safety in de standaardbibliotheek van C++
Naslaginformatie over de C++ standaard bibliotheek