unordered_map-klass

Klassmallen beskriver ett objekt som styr en sekvens med varierande längd av element av typen std::pair<const Key, Ty>. Sekvensen är svagt ordnad av en hash-funktion, som partitionerar sekvensen i en ordnad uppsättning underfrågor som kallas bucketar. I varje bucket avgör en jämförelsefunktion om ett par element har motsvarande ordning. Varje element lagrar två objekt, en sorteringsnyckel och ett värde. Sekvensen representeras på ett sätt som tillåter sökning, infogning och borttagning av ett godtyckligt element med åtgärder som kan vara oberoende av antalet element i sekvensen (konstant tid), åtminstone när alla bucketar är ungefär lika långa. I värsta fall, när alla element finns i en bucket, är antalet åtgärder proportionella mot antalet element i sekvensen (linjär tid). Om du infogar ett element ogiltigförklaras dessutom inga iteratorer, och om du tar bort ett element ogiltigförklaras endast de iteratorer som pekar på det borttagna elementet.

Syntax

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

Parametrar

Key
Nyckeltypen.

Ty
Den mappade typen.

Hash
Objekttypen hash-funktion.

Pred
Objekttypen för likhetsjämförelsefunktionen.

Alloc
Allokeringsklassen.

Medlemmar

Anmärkningar

Objektet beställer sekvensen som det styr genom att anropa två lagrade objekt, ett jämförelsefunktionsobjekt av typen unordered_map::key_equal och ett hash-funktionsobjekt av typen unordered_map::hasher. Du kommer åt det första lagrade objektet genom att anropa medlemsfunktionen unordered_map::key_eq(); och du kommer åt det andra lagrade objektet genom att anropa medlemsfunktionen unordered_map::hash_function(). Specifikt för alla värden X och Y av typen Keyreturnerar anropet key_eq()(X, Y) endast sant om de två argumentvärdena har motsvarande ordning. anropet hash_function()(keyval) ger en fördelning av värden av typen size_t. Till skillnad från klassmallen unordered_multimapsäkerställer ett typobjekt unordered_map att det key_eq()(X, Y) alltid är falskt för två element i den kontrollerade sekvensen. (Nycklar är unika.)

Objektet lagrar också en maximal belastningsfaktor, som anger det maximala önskade genomsnittliga antalet element per bucket. Om infogning av ett element orsakar unordered_map::load_factor() överskrider den maximala belastningsfaktorn ökar containern antalet bucketar och återskapar hash-tabellen efter behov.

Den faktiska ordningen på element i den kontrollerade sekvensen beror på hash-funktionen, jämförelsefunktionen, insättningsordningen, den maximala belastningsfaktorn och det aktuella antalet bucketar. Du kan i allmänhet inte förutsäga ordningen på element i den kontrollerade sekvensen. Du kan dock alltid vara säker på att alla delmängder av element som har motsvarande ordning ligger intill varandra i den kontrollerade sekvensen.

Objektet allokerar och frigör lagring för den sekvens som det styr via ett lagrat allokeringsobjekt av typen unordered_map::allocator_type. Ett sådant allokeringsobjekt måste ha samma externa gränssnitt som ett objekt av typen allocator. Det lagrade allokeringsobjektet kopieras inte när containerobjektet tilldelas.

Krav

rubrik:<unordered_map>

namnområde: std

unordered_map::allocator_type

Typ av allokerare för hantering av lagring.

typedef Alloc allocator_type;

Anmärkningar

Typen är en synonym för mallparametern Alloc.

Exempel

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

typedef std::unordered_map<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_map::at

Söker efter ett element i en unordered_map med ett angivet nyckelvärde.

Ty& at(const Key& key);
const Ty& at(const Key& key) const;

Parametrar

key
Nyckelvärdet som ska hittas.

Returvärde

En referens till datavärdet för elementet som hittades.

Anmärkningar

Om argumentnyckelvärdet inte hittas genererar funktionen ett objekt av klass out_of_range.

Exempel

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

typedef std::unordered_map<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));

    // find and show elements
    std::cout << "c1.at('a') == " << c1.at('a') << std::endl;
    std::cout << "c1.at('b') == " << c1.at('b') << std::endl;
    std::cout << "c1.at('c') == " << c1.at('c') << std::endl;

    return (0);
}

unordered_map::begin

Anger början av den kontrollerade sekvensen eller en bucket.

iterator begin();
const_iterator begin() const;
local_iterator begin(size_type nbucket);
const_local_iterator begin(size_type nbucket) const;

Parametrar

nbucket
Bucketnumret.

Anmärkningar

De två första medlemsfunktionerna returnerar en framåtriktad iterator som pekar på det första elementet i sekvensen (eller strax utanför slutet av en tom sekvens). De två sista medlemsfunktionerna returnerar en vidarebefordran iterator som pekar på det första elementet i bucketen nbucket (eller strax efter slutet av en tom bucket).

Exempel

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

typedef std::unordered_map<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_map::bucket

Hämtar bucketnumret för ett nyckelvärde.

size_type bucket(const Key& keyval) const;

Parametrar

keyval
Nyckelvärdet som ska mappas.

Anmärkningar

Medlemsfunktionen returnerar det bucketnummer som för närvarande motsvarar nyckelvärdet keyval.

Exempel

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

typedef std::unordered_map<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_map::bucket_count

Hämtar antalet bucketar.

size_type bucket_count() const;

Anmärkningar

Medlemsfunktionen returnerar det aktuella antalet bucketar.

Exempel

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

typedef std::unordered_map<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_map::bucket_size

Hämtar storleken på en bucket

size_type bucket_size(size_type nbucket) const;

Parametrar

nbucket
Bucketnumret.

Anmärkningar

Medlemsfunktionerna returnerar storleken på bucketnummer nbucket.

Exempel

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

typedef std::unordered_map<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_map::cbegin

Returnerar en const iterator som adresserar det första elementet i intervallet.

const_iterator cbegin() const;

Returvärde

En const iterator för vidarebefordran som pekar på det första elementet i intervallet, eller platsen precis utanför slutet av ett tomt intervall (för ett tomt intervall cbegin() == cend()).

Anmärkningar

Med returvärdet för cbeginkan elementen i intervallet inte ändras.

Du kan använda den här medlemsfunktionen i stället för funktionen begin() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det med nyckelordet auto typavdrag, som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder begin() och cbegin().

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

// i2 is Container<T>::const_iterator

unordered_map::cend

Returnerar en const iterator som adresserar platsen precis utanför det sista elementet i ett intervall.

const_iterator cend() const;

Returvärde

En const iterator för vidarebefordran som pekar precis utanför intervallets slut.

Anmärkningar

cend används för att testa om en iterator har passerat slutet av sitt intervall.

Du kan använda den här medlemsfunktionen i stället för funktionen end() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det med nyckelordet auto typavdrag, som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder end() och cend().

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

Värdet som returneras av cend ska inte derefereras.

unordered_map::clear

Tar bort alla element.

void clear();

Anmärkningar

Medlemsfunktionen anropar unordered_map::erase(unordered_map::begin(), unordered_map::end()), se unordered_map::erase, unordered_map::beginoch unordered_map::end.

Exempel

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

typedef std::unordered_map<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_map::const_iterator

Typen av en konstant iterator för den kontrollerade sekvensen.

typedef T1 const_iterator;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en konstant vidarebefordran iterator för den kontrollerade sekvensen. Det beskrivs här som en synonym för den implementeringsdefinierade typen T1.

Exempel

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

typedef std::unordered_map<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_map::const_local_iterator

Typen av en konstant bucket-iterator för den kontrollerade sekvensen.

typedef T5 const_local_iterator;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en konstant vidarebefordran iterator för en bucket. Det beskrivs här som en synonym för den implementeringsdefinierade typen T5.

Exempel

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

typedef std::unordered_map<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_map::const_pointer

Typen av en konstant pekare till ett element.

typedef Alloc::const_pointer const_pointer;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en konstant pekare till ett element i den kontrollerade sekvensen.

Exempel

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

typedef std::unordered_map<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_map::const_reference

Typen av en konstant referens till ett element.

typedef Alloc::const_reference const_reference;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en konstant referens till ett element i den kontrollerade sekvensen.

Exempel

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

typedef std::unordered_map<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_map::contains

Kontrollerar om det finns ett element i unordered_map med den angivna nyckeln. Introducerades i C++20.

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

Parametrar

K
Typ av nyckel.

key
Nyckelvärdet för elementet som ska sökas efter.

Returvärde

true om elementet finns i containern. false annars.

Anmärkningar

contains() är nytt i C++20. Om du vill använda den anger du alternativet /std:c++20 eller senare kompilator.

template<class K> bool contains(const K& key) const deltar endast i överbelastningsmatchning om key_compare är transparent.

Exempel

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

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

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

    return 0;
}

true
false

unordered_map::count

Hittar antalet element som matchar en angiven nyckel.

size_type count(const Key& keyval) const;

Parametrar

keyval
Nyckelvärde att söka efter.

Anmärkningar

Medlemsfunktionen returnerar antalet element i intervallet som avgränsas av unordered_map::equal_range(keyval).

Exempel

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

typedef std::unordered_map<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_map::difference_type

Typen av ett signerat avstånd mellan två element.

typedef T3 difference_type;

Anmärkningar

Den signerade heltalstypen beskriver ett objekt som kan representera skillnaden mellan adresserna för två element i den kontrollerade sekvensen. Det beskrivs här som en synonym för den implementeringsdefinierade typen T3.

Exempel

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

typedef std::unordered_map<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_map::emplace

Infogar ett element som konstruerats på plats (inga kopierings- eller flyttåtgärder utförs) i en unordered_map.

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

Parametrar

args
Argumenten som vidarebefordras för att konstruera ett element som ska infogas i unordered_map om det inte redan innehåller ett element vars värde är ordnat på motsvarande sätt.

Returvärde

En pair vars bool komponent returnerar sant om en insättning gjordes och falskt om unordered_map redan innehöll ett element vars nyckel hade ett motsvarande värde i ordningen och vars iteratorkomponent returnerar adressen där ett nytt element infogades eller där elementet redan fanns.

Om du vill komma åt iteratorkomponenten i ett par pr som returneras av den här medlemsfunktionen använder du pr.firstoch använder *(pr.first)för att avrefereras. Om du vill komma åt bool komponenten i ett par pr returneras av den här medlemsfunktionen använder du pr.second.

Anmärkningar

Inga iteratorer eller referenser har ogiltigförklarats av den här funktionen.

Om ett undantag utlöses under infogningen men inte inträffar i containerns hash-funktion ändras inte containern. Om undantaget genereras i hash-funktionen är resultatet odefinierat.

Ett kodexempel finns i map::emplace.

unordered_map::emplace_hint

Infogar ett element som är konstruerat på plats (inga kopierings- eller flyttåtgärder utförs) med ett placeringstips.

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

Parametrar

args
Argumenten som vidarebefordras för att konstruera ett element som ska infogas i unordered_map om inte unordered_map redan innehåller elementet eller, mer allmänt, om det inte redan innehåller ett element vars nyckel är ordnad på motsvarande sätt.

where
Ett tips om platsen där du kan börja söka efter rätt insättningspunkt.

Returvärde

En iterator till det nyligen infogade elementet.

Om infogningen misslyckades eftersom elementet redan finns returnerar en iterator till det befintliga elementet.

Anmärkningar

Inga referenser har ogiltigförklarats av den här funktionen.

Om ett undantag utlöses under infogningen men inte inträffar i containerns hash-funktion ändras inte containern. Om undantaget genereras i hash-funktionen är resultatet odefinierat.

value_type för ett element är ett par, så att värdet för ett element blir ett ordnat par med den första komponenten lika med nyckelvärdet och den andra komponenten som är lika med elementets datavärde.

Ett kodexempel finns i map::emplace_hint.

unordered_map::empty

Testar om det inte finns några element.

bool empty() const;

Anmärkningar

Medlemsfunktionen returnerar true för en tom kontrollerad sekvens.

Exempel

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

typedef std::unordered_map<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_map::end

Anger slutet på den kontrollerade sekvensen.

iterator end();
const_iterator end() const;
local_iterator end(size_type nbucket);
const_local_iterator end(size_type nbucket) const;

Parametrar

nbucket
Bucketnumret.

Anmärkningar

De två första medlemsfunktionerna returnerar en vidarebefordran iterator som pekar precis utanför slutet av sekvensen. De två sista medlemsfunktionerna returnerar en vidarebefordran iterator som pekar precis utanför slutet av bucketen nbucket.

unordered_map::equal_range

Söker efter intervall som matchar en angiven nyckel.

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

Parametrar

keyval
Nyckelvärde att söka efter.

Anmärkningar

Medlemsfunktionen returnerar ett par iteratorer X så att [X.first, X.second) avgränsar bara de element i den kontrollerade sekvensen som har motsvarande ordning med keyval. Om det inte finns några sådana element är båda iteratorerna end().

Exempel

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

typedef std::unordered_map<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_map::erase

Tar bort ett element eller ett område med element i en unordered_map från angivna positioner eller tar bort element som matchar en angiven nyckel.

iterator erase(const_iterator Where);
iterator erase(const_iterator First, const_iterator Last);
size_type erase(const key_type& Key);

Parametrar

Where
Positionen för elementet som ska tas bort.

First
Positionen för det första elementet som ska tas bort.

Last
Placera precis utanför det sista elementet som ska tas bort.

Key
Nyckelvärdet för de element som ska tas bort.

Returvärde

För de två första medlemsfunktionerna, en dubbelriktad iterator som anger det första elementet som återstår utöver alla element som tas bort, eller ett element som är slutet på kartan om det inte finns något sådant element.

För den tredje medlemsfunktionen returnerar antalet element som har tagits bort från unordered_map.

Anmärkningar

Ett kodexempel finns i map::erase.

unordered_map::find

Hittar ett element som matchar en angiven nyckel.

const_iterator find(const Key& keyval) const;

Parametrar

keyval
Nyckelvärde att söka efter.

Anmärkningar

Medlemsfunktionen returnerar unordered_map::equal_range(keyval).first.

Exempel

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

typedef std::unordered_map<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_map::get_allocator

Hämtar det lagrade allokeringsobjektet.

Alloc get_allocator() const;

Anmärkningar

Medlemsfunktionen returnerar det lagrade allokeringsobjektet.

Exempel

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

typedef std::unordered_map<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_map::hash_function

Hämtar det lagrade hash-funktionsobjektet.

Hash hash_function() const;

Anmärkningar

Medlemsfunktionen returnerar det lagrade hash-funktionsobjektet.

Exempel

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

typedef std::unordered_map<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_map::hasher

Typen av hash-funktion.

typedef Hash hasher;

Anmärkningar

Typen är en synonym för mallparametern Hash.

Exempel

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

typedef std::unordered_map<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_map::insert

Infogar ett element eller ett område med element i en unordered_map.

// (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);

Parametrar

Val
Värdet för ett element som ska infogas i unordered_map om det inte redan innehåller ett element vars nyckel är ordnad på motsvarande sätt.

Where
Platsen där du vill börja söka efter rätt insättningspunkt.

ValTy
Mallparameter som anger den argumenttyp som unordered_map kan använda för att konstruera ett element i value_typeoch Val som ett argument.

First
Positionen för det första element som ska kopieras.

Last
Positionen precis utanför det sista element som ska kopieras.

InputIterator
Mallfunktionsargument som uppfyller kraven för en indata iterator som pekar på element av en typ som kan användas för att konstruera value_type objekt.

IList
Den initializer_list som elementen ska kopieras från.

Returvärde

Medlemsfunktionerna med ett element, (1) och (2), returnerar en pair vars bool komponent true om en insättning gjordes och false om unordered_map redan innehöll ett element vars nyckel hade ett motsvarande värde i ordningen. Iteratorkomponenten i retur/värde-paret pekar på det nyligen infogade elementet om den bool komponenten är trueeller till det befintliga elementet om bool komponenten false.

Medlemsfunktionerna single-element-with-hint, (3) och (4), returnerar en iterator som pekar på positionen där det nya elementet infogades i unordered_map eller, om ett element med en motsvarande nyckel redan finns, till det befintliga elementet.

Anmärkningar

Inga iteratorer, pekare eller referenser har ogiltigförklarats av den här funktionen.

Om ett undantag utlöses men inte inträffar i containerns hash-funktion ändras inte containerns tillstånd under infogningen av bara ett element. Om undantaget genereras i hash-funktionen är resultatet odefinierat. Om ett undantag utlöses under införandet av flera element lämnas containern i ett ospecificerat men giltigt tillstånd.

Om du vill komma åt iteratorkomponenten i en pairpr som returneras av medlemsfunktionerna med ett element använder du pr.first; om du vill avrefereras iteratorn i det returnerade paret använder du *pr.first, vilket ger dig ett element. Om du vill komma åt komponenten bool använder du pr.second. Ett exempel finns i exempelkoden senare i den här artikeln.

value_type för en container är en typedef som tillhör containern, och för mappning är map<K, V>::value_typepair<const K, V>. Värdet för ett element är ett ordnat par där den första komponenten är lika med nyckelvärdet och den andra komponenten är lika med elementets datavärde.

Funktionen range member (5) infogar sekvensen med elementvärden i en unordered_map som motsvarar varje element som hanteras av en iterator i intervallet [First, Last); därför infogas inte Last. Funktionen containermedlem end() refererar till positionen strax efter det sista elementet i containern– till exempel försöker instruktionen m.insert(v.begin(), v.end()); infoga alla element i v i m. Endast element som har unika värden i intervallet infogas. dubbletter ignoreras. Om du vill se vilka element som avvisas använder du enelementsversionerna av insert.

Medlemsfunktionen i initieringslistan (6) använder en initializer_list för att kopiera element till unordered_map.

För infogning av ett element som konstruerats på plats, dvs. inga kopierings- eller flyttåtgärder utförs, se unordered_map::emplace och unordered_map::emplace_hint.

Ett kodexempel finns i map::insert.

unordered_map::iterator

Typ av iterator för den kontrollerade sekvensen.

typedef T0 iterator;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en vidarebefordrande iterator för den kontrollerade sekvensen. Det beskrivs här som en synonym för den implementeringsdefinierade typen T0.

Exempel

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

typedef std::unordered_map<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_map::key_eq

Hämtar det lagrade jämförelsefunktionsobjektet.

Pred key_eq() const;

Anmärkningar

Medlemsfunktionen returnerar det lagrade jämförelsefunktionsobjektet.

Exempel

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

typedef std::unordered_map<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_map::key_equal

Typen av jämförelsefunktion.

typedef Pred key_equal;

Anmärkningar

Typen är en synonym för mallparametern Pred.

Exempel

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

typedef std::unordered_map<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_map::key_type

Typ av beställningsnyckel.

typedef Key key_type;

Anmärkningar

Typen är en synonym för mallparametern Key.

Exempel

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

typedef std::unordered_map<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_map::load_factor

Räknar de genomsnittliga elementen per bucket.

float load_factor() const;

Anmärkningar

Medlemsfunktionen returnerar (float)unordered_map::size() / (float)unordered_map::bucket_count(), det genomsnittliga antalet element per bucket, se unordered_map::size och unordered_map::bucket_count.

Exempel

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

typedef std::unordered_map<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_map::local_iterator

Typen av bucket iterator.

typedef T4 local_iterator;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en vidarebefordrande iterator för en bucket. Det beskrivs här som en synonym för den implementeringsdefinierade typen T4.

Exempel

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

typedef std::unordered_map<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_map::mapped_type

Typen av ett mappat värde som är associerat med varje nyckel.

typedef Ty mapped_type;

Anmärkningar

Typen är en synonym för mallparametern Ty.

Exempel

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

typedef std::unordered_map<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_map::max_bucket_count

Hämtar det maximala antalet bucketar.

size_type max_bucket_count() const;

Anmärkningar

Medlemsfunktionen returnerar det maximala antalet bucketar som för närvarande tillåts.

Exempel

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

typedef std::unordered_map<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_map::max_load_factor

Hämtar eller anger maximalt antal element per bucket.

float max_load_factor() const;

void max_load_factor(float factor);

Parametrar

factor
Den nya maxbelastningsfaktorn.

Anmärkningar

Den första medlemsfunktionen returnerar den lagrade maxbelastningsfaktorn. Den andra medlemsfunktionen ersätter den lagrade maxbelastningsfaktorn med factor.

Exempel

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

typedef std::unordered_map<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_map::max_size

Hämtar maximal storlek för den kontrollerade sekvensen.

size_type max_size() const;

Anmärkningar

Medlemsfunktionen returnerar längden på den längsta sekvens som objektet kan styra.

Exempel

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

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

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

    return (0);
    }

max_size() == 536870911

unordered_map::operator[]

Söker efter eller infogar ett element med den angivna nyckeln.

Ty& operator[](const Key& keyval);

Ty& operator[](Key&& keyval);

Parametrar

keyval
Nyckelvärdet som ska hittas eller infogas.

Returvärde

En referens till datavärdet för det infogade elementet.

Anmärkningar

Om argumentnyckelvärdet inte hittas infogas det tillsammans med standardvärdet för datatypen.

operator[] kan användas för att infoga element i en karta m med hjälp av m[Key] = DataValue; där DataValue är värdet för elementets mapped_type med nyckelvärdet Key.

Medlemsfunktionen avgör iteratorn where som returvärdet för unordered_map::insert(unordered_map::value_type(keyval, Ty()). Mer information finns i unordered_map::insert och unordered_map::value_type. (Det infogar ett element med den angivna nyckeln om det inte finns något sådant element.) Den returnerar sedan en referens till (*where).second.

När du använder operator[] för att infoga element anger den returnerade referensen inte om en infogning ändrar ett befintligt element eller skapar ett nytt. Medlemsfunktionerna find och insert kan användas för att avgöra om ett element med en angiven nyckel redan finns före en infogning.

Exempel

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

typedef std::unordered_map<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 << "c1['A'] == " << c1['A'] << std::endl;

// try to find and succeed
    std::cout << "c1['a'] == " << c1['a'] << std::endl;

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

// insert by moving key
    std::unordered_map<string, int> c2;
    std::string str("abc");
    std::cout << "c2[std::move(str)] == " << c2[std::move(str)] << std::endl;
    std::cout << "c2["abc"] == " << c2["abc"] << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
c1['A'] == 0
c1['a'] == 1
[c, 3] [b, 2] [A, 0] [a, 1]
c2[move(str)] == 0
c2["abc"] == 1

unordered_map::operator=

Ersätter elementen i den här unordered_map med hjälp av elementen från en annan unordered_map.

unordered_map& operator=(const unordered_map& right);

unordered_map& operator=(unordered_map&& right);

Parametrar

right
Den unordered_map som operatorfunktionen tilldelar innehåll från.

Anmärkningar

Den första versionen kopierar alla element från right till den här unordered_map.

Den andra versionen flyttar alla element från right till den här unordered_map.

Alla element som finns i den här unordered_map innan operator= körs ignoreras.

Exempel

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

int main( )
   {
   using namespace std;
   unordered_map<int, int> v1, v2, v3;
   unordered_map<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_map::pointer

Typ av pekare till ett element.

typedef Alloc::pointer pointer;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en pekare till ett element i den kontrollerade sekvensen.

Exempel

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

typedef std::unordered_map<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_map::reference

Typen av referens till ett element.

typedef Alloc::reference reference;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en referens till ett element i den kontrollerade sekvensen.

Exempel

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

typedef std::unordered_map<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_map::rehash

Återskapar hash-tabellen.

void rehash(size_type nbuckets);

Parametrar

nbuckets
Det begärda antalet bucketar.

Anmärkningar

Medlemsfunktionen ändrar antalet bucketar som ska vara minst nbuckets och återskapar hash-tabellen efter behov.

Exempel

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

typedef std::unordered_map<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_map::size

Räknar antalet element.

size_type size() const;

Anmärkningar

Medlemsfunktionen returnerar längden på den kontrollerade sekvensen.

Exempel

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

typedef std::unordered_map<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_map::size_type

Typen av ett osignerat avstånd mellan två element.

typedef T2 size_type;

Anmärkningar

Den osignerade heltalstypen beskriver ett objekt som kan representera längden på valfri kontrollerad sekvens. Det beskrivs här som en synonym för den implementeringsdefinierade typen T2.

Exempel

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

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

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

    return (0);
    }

size == 0

unordered_map::swap

Växlar innehållet i två containrar.

void swap(unordered_map& right);

Parametrar

right
Containern som ska växlas med.

Anmärkningar

Medlemsfunktionen växlar de kontrollerade sekvenserna mellan *this och right. Om unordered_map::get_allocator() == right.get_allocator(), se unordered_map::get_allocator, det gör det i konstant tid, genererar det endast ett undantag som ett resultat av att det lagrade egenskapsobjektet av typen Tr, och det ogiltigförklarar inga referenser, pekare eller iteratorer som anger element i de två kontrollerade sekvenserna. Annars utför den elementtilldelningar och konstruktoranrop som är proportionella mot antalet element i de två kontrollerade sekvenserna.

Exempel

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

typedef std::unordered_map<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_map::unordered_map

Skapar ett containerobjekt.

unordered_map(const unordered_map& Right);

explicit unordered_map(
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Allocator());

unordered_map(unordered_map&& Right);
unordered_map(initializer_list<Type> IList);
unordered_map(initializer_list<Type> IList, size_type Bucket_count);

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

unordered_map(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    KeyEqual& equal);

unordered_map(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    KeyEqual& Equal
    const Allocator& Al);

template <class InIt>
unordered_map(
    InputIterator First,
    InputIterator Last,
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

Parametrar

Al
Allokeringsobjektet som ska lagras.

Comp
Jämförelsefunktionsobjektet som ska lagras.

Hash
Det hash-funktionsobjekt som ska lagras.

Bucket_count
Det minsta antalet bucketar.

Right
Containern som ska kopieras.

First
Positionen för det första element som ska kopieras.

Last
Positionen precis utanför det sista element som ska kopieras.

IList
Den initializer_list som innehåller de element som ska kopieras.

Anmärkningar

Den första konstruktorn anger en kopia av sekvensen som styrs av right. Den andra konstruktorn anger en tom kontrollerad sekvens. Den tredje konstruktorn infogar sekvensen med elementvärden [first, last). Den fjärde konstruktorn anger en kopia av sekvensen genom att flytta right.

Alla konstruktorer initierar också flera lagrade värden. För kopieringskonstruktorn hämtas värdena från Right. Annars:

Det minsta antalet bucketar är argumentet Bucket_count, om det finns. annars är det ett standardvärde som beskrivs här som det implementeringsdefinierade värdet N0.

hash-funktionsobjektet är argumentet Hash, om det finns; annars är det Hash().

Jämförelsefunktionsobjektet är argumentet Comp, om det finns; annars är det Pred().

Allokeringsobjektet är argumentet Al, om det finns; annars är det Alloc().

Exempel

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

using namespace std;

using Mymap = unordered_map<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;
    cout << endl;

    // Construct with an initializer_list
    unordered_map<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_map<int, char> c6({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } }, 4);
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;
    cout << endl;

    // Initializer_list plus size and hash
    unordered_map<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_map<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_map<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]

unordered_map::value_type

Typ av element.

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

Anmärkningar

Typen beskriver ett element i den kontrollerade sekvensen.

Exempel

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

typedef std::unordered_map<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]

Se även

<unordered_map>
Trådsäkerhet i C++ Standard Library