unordered_set-klass

Klassmallen beskriver ett objekt som styr en sekvens med varierande längd av element av typen const Key. 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 fungerar som både 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 ett antal å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 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 Hash = std::hash<Key>,
   class Pred = std::equal_to<Key>,
   class Alloc = std::allocator<Key>>
class unordered_set;

Parameterar

Key
Nyckeltypen.

Hash
Objekttypen hash-funktion.

Pred
Objekttypen för likhetsjämförelsefunktionen.

Alloc
Allokeringsklassen.

Medlemmar

Typedefs

Funktionen

Operatörer

Anmärkningar

Objektet beställer sekvensen som det styr genom att anropa två lagrade objekt, ett jämförelsefunktionsobjekt av typen unordered_set::key_equal och ett hash-funktionsobjekt av typen unordered_set::hasher. Du kommer åt det första lagrade objektet genom att anropa medlemsfunktionen unordered_set::key_eq(); och du kommer åt det andra lagrade objektet genom att anropa medlemsfunktionen unordered_set::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_multisetsäkerställer ett typobjekt unordered_set 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_set::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_set::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.

unordered_set::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_set__unordered_set_allocator_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

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

    Myset::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

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;

Parameterar

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

// unordered_set_begin.cpp
// compile using: cl.exe /EHsc /nologo /W4 /MTd
#include <unordered_set>
#include <iostream>

using namespace std;

typedef unordered_set<char> MySet;

int main()
{
    MySet c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents using range-based for
    for (auto it : c1) {
    cout << "[" << it << "] ";
    }

    cout << endl;

    // display contents using explicit for
    for (MySet::const_iterator it = c1.begin(); it != c1.end(); ++it) {
        cout << "[" << *it << "] ";
    }

    cout << std::endl;

    // display first two items
    MySet::iterator it2 = c1.begin();
    cout << "[" << *it2 << "] ";
    ++it2;
    cout << "[" << *it2 << "] ";
    cout << endl;

    // display bucket containing 'a'
    MySet::const_local_iterator lit = c1.begin(c1.bucket('a'));
    cout << "[" << *lit << "] ";

    return (0);
}

[a] [b] [c]
[a] [b] [c]
[a] [b]
[a]

bucket

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

size_type bucket(const Key& keyval) const;

Parameterar

keyval
Nyckelvärdet som ska mappas.

Anmärkningar

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

Exempel

// std__unordered_set__unordered_set_bucket.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display buckets for keys
    Myset::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] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

bucket_count

Hämtar antalet bucketar.

size_type bucket_count() const;

Anmärkningar

Medlemsfunktionen returnerar det aktuella antalet bucketar.

Exempel

// std__unordered_set__unordered_set_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    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] [b] [a]
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

bucket_size

Hämtar storleken på en bucket

size_type bucket_size(size_type nbucket) const;

Parameterar

nbucket
Bucketnumret.

Anmärkningar

Medlemsfunktionerna returnerar storleken på bucketnummer nbucket.

Exempel

// std__unordered_set__unordered_set_bucket_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display buckets for keys
    Myset::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] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

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 tillsammans 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 isContainer<T>::iterator
auto i2 = Container.cbegin();

// i2 isContainer<T>::const_iterator

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 tillsammans 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 isContainer<T>::iterator
auto i2 = Container.cend();

// i2 isContainer<T>::const_iterator

Värdet som returneras av cend ska inte derefereras.

clear

Tar bort alla element.

void clear();

Anmärkningar

Medlemsfunktionen anropar unordered_set::erase( unordered_set::begin(), unordered_set::end()). Mer information finns i unordered_set::erase, unordered_set::beginoch unordered_set::end.

Exempel

// std__unordered_set__unordered_set_clear.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    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('d');
    c1.insert('e');

    // display contents "[e] [d] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

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

    return (0);
}

[c] [b] [a]
size == 0
empty() == true
[e] [d]
size == 2
empty() == false

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_set__unordered_set_const_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
    std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

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_set__unordered_set_const_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a]

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_set__unordered_set_const_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
    {
        Myset::const_pointer p = &*it;
        std::cout << "[" << *p << "] ";
    }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

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_set__unordered_set_const_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

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

    return (0);
}

[c] [b] [a]

contains

Kontrollerar om det finns ett element med den angivna nyckeln i unordered_set.

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

Parameterar

K
Typ av nyckel.

Key
Elementets nyckelvärde att söka 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 kompileringsalternativet /std:c++20 eller senare.

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_set>
#include <iostream>

int main()
{
    std::unordered_set<int> theUnorderedSet = { 1, 2 };

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

    return 0;
}

true
false

count

Hittar antalet element som matchar en angiven nyckel.

size_type count(const Key& keyval) const;

Parameterar

keyval
Nyckelvärde att söka efter.

Anmärkningar

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

Exempel

// std__unordered_set__unordered_set_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    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] [b] [a]
count('A') == 0
count('b') == 1
count('C') == 0

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_set__unordered_set_difference_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

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

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

    return (0);
}

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

emplace

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

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

Parameterar

args
Argumenten som vidarebefordras för att konstruera ett element som ska infogas i unordered_set 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_set 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 set::emplace.

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_iteratorwhere,
Args&&... args);

Parameterar

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

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 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 set::emplace_hint.

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_set__unordered_set_empty.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    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('d');
    c1.insert('e');

    // display contents "[e] [d] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

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

    return (0);
}

[c] [b] [a]
size == 0
empty() == true
[e] [d]
size == 2
empty() == false

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;

Parameterar

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.

Exempel

// std__unordered_set__unordered_set_end.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect last two items "[a] [b] "
    Myset::iterator it2 = c1.end();
    --it2;
    std::cout << "[" << *it2 << "] ";
    --it2;
    std::cout << "[" << *it2 << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.end(c1.bucket('a'));
    --lit;
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a] [b]
[a]

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;

Parameterar

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_set__unordered_set_equal_range.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

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

    return (0);
}

[c] [b] [a]
equal_range('x'):
equal_range('b'): [b]

erase

Tar bort ett element eller ett område med element i en unordered_set 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);

Parameterar

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å unordered_set om det inte finns något sådant element.

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

Anmärkningar

Ett kodexempel finns i set::erase.

find

Hittar ett element som matchar en angiven nyckel.

const_iterator find(const Key& keyval) const;

Parameterar

keyval
Nyckelvärde att söka efter.

Anmärkningar

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

Exempel

// std__unordered_set__unordered_set_find.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    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
    Myset::iterator it = c1.find('b');
    std::cout << "find('b') == "
    << std::boolalpha << (it != c1.end())
    << ": [" << *it << "] " << std::endl;

    return (0);
}

[c] [b] [a]
find('A') == false
find('b') == true: [b]

get_allocator

Hämtar det lagrade allokeringsobjektet.

Alloc get_allocator() const;

Anmärkningar

Medlemsfunktionen returnerar det lagrade allokeringsobjektet.

Exempel

// std__unordered_set__unordered_set_get_allocator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

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

    Myset::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

hash_function

Hämtar det lagrade hash-funktionsobjektet.

Hash hash_function() const;

Anmärkningar

Medlemsfunktionen returnerar det lagrade hash-funktionsobjektet.

Exempel

// std__unordered_set__unordered_set_hash_function.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    Myset::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

hasher

Typen av hash-funktion.

typedef Hash hasher;

Anmärkningar

Typen är en synonym för mallparametern Hash.

Exempel

// std__unordered_set__unordered_set_hasher.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    Myset::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

insert

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

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

Parameterar

Val
Värdet för ett element som ska infogas i unordered_set 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_set kan användas för att konstruera ett element i value_typeoch perfekt vidarebefordran 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 är sann om en insättning gjordes och falskt om den unordered_set redan innehåller 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_set 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 pr.firstdu ; för att avrefereras iteratorn i det returnerade paret använder*pr.first du, 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.

För value_type en container är en typedef som tillhör containern och, för angivet, unordered_set<V>::value_type är typ const V.

Funktionen range member (5) infogar sekvensen med elementvärden i en unordered_set som motsvarar varje element som hanteras av en iterator i intervallet [First, Last). Därför Last infogas inte. Funktionen containermedlem end() refererar till positionen strax efter det sista elementet i containern– till exempel försöker instruktionen s.insert(v.begin(), v.end()); infoga alla element i v i s. 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_set.

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

Ett kodexempel finns i set::insert.

iterator

En typ som ger en konstant vidarebefordran iterator som kan läsa element i en unordered_set.

typedef implementation-defined iterator;

Exempel

Se exemplet för begin ett exempel på hur du deklarerar och använder en iterator.

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_set__unordered_set_key_eq.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    Myset::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

key_equal

Typen av jämförelsefunktion.

typedef Pred key_equal;

Anmärkningar

Typen är en synonym för mallparametern Pred.

Exempel

// std__unordered_set__unordered_set_key_equal.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    Myset::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

key_type

Typ av beställningsnyckel.

typedef Key key_type;

Anmärkningar

Typen är en synonym för mallparametern Key.

Exempel

// std__unordered_set__unordered_set_key_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // add a value and reinspect
    Myset::key_type key = 'd';
    Myset::value_type val = key;
    c1.insert(val);

    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[d] [c] [b] [a]

load_factor

Räknar de genomsnittliga elementen per bucket.

float load_factor() const;

Anmärkningar

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

Exempel

// std__unordered_set__unordered_set_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    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] [b] [a]
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

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_set__unordered_set_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a]

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_set__unordered_set_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    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] [b] [a]
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

max_load_factor

Hämtar eller anger maximalt antal element per bucket.

float max_load_factor() const;

void max_load_factor(float factor);

Parameterar

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_set__unordered_set_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    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] [b] [a]
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

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_set__unordered_set_max_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

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

    return (0);
}

max_size() == 4294967295

operator=

Kopierar en hash-tabell.

unordered_set& operator=(const unordered_set& right);

unordered_set& operator=(unordered_set&& right);

Parameterar

right
Den unordered_set som kopieras till unordered_set.

Anmärkningar

När du har raderat befintliga element i en unordered_setkopierar operator= eller flyttar du innehållet right i till unordered_set.

Exempel

// unordered_set_operator_as.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

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

    v1.insert(10);

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

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

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

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_set__unordered_set_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
    {
        Myset::key_type key = *it;
        Myset::pointer p = &key;
        std::cout << "[" << *p << "] ";
    }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

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_set__unordered_set_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
    {
        Myset::key_type key = *it;
        Myset::reference ref = key;
        std::cout << "[" << ref << "] ";
    }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

rehash

Återskapar hash-tabellen.

void rehash(size_type nbuckets);

Parameterar

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_set__unordered_set_rehash.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    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] [b] [a]
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

size

Räknar antalet element.

size_type size() const;

Anmärkningar

Medlemsfunktionen returnerar längden på den kontrollerade sekvensen.

Exempel

// std__unordered_set__unordered_set_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    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('d');
    c1.insert('e');

    // display contents "[e] [d] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

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

    return (0);
}

[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

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_set__unordered_set_size_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;
    Myset::size_type sz = c1.size();

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

    return (0);
}

size == 0

swap

Växlar innehållet i två containrar.

void swap(unordered_set& right);

Parameterar

right
Containern som ska växlas med.

Anmärkningar

Medlemsfunktionen växlar de kontrollerade sekvenserna mellan *this och right. Om unordered_set::get_allocator() == right.get_allocator(), det gör det i konstant tid, genererar det ett undantag endast som ett resultat av att kopiera 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 ett antal elementtilldelningar och konstruktoranrop som är proportionella mot antalet element i de två kontrollerade sekvenserna.

Exempel

// std__unordered_set__unordered_set_swap.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    Myset c2;

    c2.insert('d');
    c2.insert('e');
    c2.insert('f');

    c1.swap(c2);

    // display contents "[f] [e] [d] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    swap(c1, c2);

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[f] [e] [d]
[c] [b] [a]

unordered_set

Skapar ett containerobjekt.

unordered_set(const unordered_set& Right);

explicit unordered_set(
    size_typebucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

unordered_set(unordered_set&& Right);

unordered_set(initializer_list<Type> IList);

unordered_set(initializer_list<Type> IList, size_typebucket_count);

unordered_set(
    initializer_list<Type> IList,
    size_typebucket_count,
    const Hash& Hash);

unordered_set(
    initializer_list<Type> IList,
    size_typebucket_count,
    const Hash& Hash,
    const Comp& Comp);

unordered_set(
    initializer_list<Type> IList,
    size_typebucket_count,
    const Hash& Hash,
    const Comp& Comp,
    const Allocator& Al);

template <class InputIterator>
unordered_set(
    InputIteratorfirst,
    InputIteratorlast,
    size_typebucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

Parameterar

InputIterator
Iteratortypen.

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.

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 anger en kopia av sekvensen genom att flytta Right Den fjärde till åttonde konstruktorerna använder en initializer_list för att ange de element som ska kopieras. Den nionde konstruktorn infogar sekvensen med elementvärden [first, last).

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 Hash()det .

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

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

value_type

Typ av element.

typedef Key value_type;

Anmärkningar

Typen beskriver ett element i den kontrollerade sekvensen.

Exempel

// std__unordered_set__unordered_set_value_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // add a value and reinspect
    Myset::key_type key = 'd';
    Myset::value_type val = key;
    c1.insert(val);

    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[d] [c] [b] [a]