unordered_set-klasse

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

Syntaxis

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

Parameterwaarden

Key
Het sleuteltype.

Hash
Het objecttype hashfunctie.

Pred
Het objecttype gelijkheidsvergelijkingsfunctie.

Alloc
De allocatorklasse.

Leden

Typedefs

Functies

Bedieners

Opmerkingen

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

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

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

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

unordered_set::allocator_type

Het type allocator voor het beheren van opslag.

typedef Alloc allocator_type;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Alloc.

Voorbeeld

// std__unordered_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

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

iterator begin();

const_iterator begin() const;

local_iterator begin(size_type nbucket);

const_local_iterator begin(size_type nbucket) const;

Parameterwaarden

nbucket
Het bucketnummer.

Opmerkingen

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

Voorbeeld

// 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

Hiermee wordt het bucketnummer voor een sleutelwaarde opgehaald.

size_type bucket(const Key& keyval) const;

Parameterwaarden

keyval
De sleutelwaarde die moet worden toegewezen.

Opmerkingen

De lidfunctie retourneert het bucketnummer dat momenteel overeenkomt met de sleutelwaarde keyval.

Voorbeeld

// 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

Hiermee haalt u het aantal buckets op.

size_type bucket_count() const;

Opmerkingen

De lidfunctie retourneert het huidige aantal buckets.

Voorbeeld

// 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

Hiermee wordt de grootte van een bucket opgehaald

size_type bucket_size(size_type nbucket) const;

Parameterwaarden

nbucket
Het bucketnummer.

Opmerkingen

De lidfuncties retourneren de grootte van het bucketnummer nbucket.

Voorbeeld

// 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

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

const_iterator cbegin() const;

Retourwaarde

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

Opmerkingen

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

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

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

// i2 isContainer<T>::const_iterator

cend

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

const_iterator cend() const;

Retourwaarde

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

Opmerkingen

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

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

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

// i2 isContainer<T>::const_iterator

De waarde die door cend wordt geretourneerd, mag niet worden gededucteerd.

clear

Hiermee verwijdert u alle elementen.

void clear();

Opmerkingen

De aanroepen unordered_set::erase( unordered_set::begin()van de lidfunctie , unordered_set::end()). Zie , unordered_set::eraseen unordered_set::beginvoor meer informatie unordered_set::end.

Voorbeeld

// 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

Het type van een constante iterator voor de gecontroleerde reeks.

typedef T1 const_iterator;

Opmerkingen

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

Voorbeeld

// std__unordered_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

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

typedef T5 const_local_iterator;

Opmerkingen

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

Voorbeeld

// std__unordered_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

Het type constante aanwijzer naar een element.

typedef Alloc::const_pointer const_pointer;

Opmerkingen

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

Voorbeeld

// std__unordered_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

Het type constante verwijzing naar een element.

typedef Alloc::const_reference const_reference;

Opmerkingen

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

Voorbeeld

// std__unordered_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

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

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

Parameterwaarden

K
Het type sleutel.

Key
De sleutelwaarde van het element waarnaar moet worden gezocht.

Retourwaarde

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

Opmerkingen

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

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

Voorbeeld

// Requires /std:c++20 or later
#include <unordered_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

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

size_type count(const Key& keyval) const;

Parameterwaarden

keyval
Sleutelwaarde om naar te zoeken.

Opmerkingen

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

Voorbeeld

// 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

Het type ondertekende afstand tussen twee elementen.

typedef T3 difference_type;

Opmerkingen

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

Voorbeeld

// std__unordered_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

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

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

Parameterwaarden

args
De argumenten die worden doorgestuurd om een element te maken dat in de unordered_set moet worden ingevoegd, tenzij het al een element bevat waarvan de waarde gelijkgeordend is.

Retourwaarde

Een pair waarvan het bool onderdeel waar retourneert als een invoeging is gemaakt en onwaar als de unordered_set al een element bevatte waarvan de sleutel een equivalente waarde in de volgorde had en waarvan het iteratoronderdeel het adres retourneert waar een nieuw element is ingevoegd of waar het element zich al bevond.

Als u toegang wilt krijgen tot het iteratoronderdeel van een paar pr geretourneerd door deze lidfunctie, gebruikt u pr.firsten deductie ervan, gebruikt u *(pr.first). Gebruik boolom toegang te krijgen tot het pr-onderdeel van een paar pr.second geretourneerd door deze lidfunctie.

Opmerkingen

Er worden geen iterators of verwijzingen ongeldig gemaakt door deze functie.

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

Zie set::emplacevoor een codevoorbeeld.

emplace_hint

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

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

Parameterwaarden

args
De argumenten die worden doorgestuurd om een element te maken dat in het unordered_set element moet worden ingevoegd, tenzij het unordered_set element al bevat of, meer in het algemeen, tenzij het al een element bevat waarvan de sleutel equivalent is gerangschikt.

where
Een hint over de plaats om te zoeken naar het juiste invoegpunt.

Retourwaarde

Een iterator voor het zojuist ingevoegde element.

Als de invoeging is mislukt omdat het element al bestaat, retourneert u een iterator naar het bestaande element.

Opmerkingen

Er worden geen iterators of verwijzingen ongeldig gemaakt door deze functie.

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

Zie set::emplace_hintvoor een codevoorbeeld.

empty

Test of er geen elementen aanwezig zijn.

bool empty() const;

Opmerkingen

De lidfunctie retourneert waar voor een lege beheerde reeks.

Voorbeeld

// 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

Geeft het einde van de gecontroleerde reeks aan.

iterator end();

const_iterator end() const;

local_iterator end(size_type nbucket);

const_local_iterator end(size_type nbucket) const;

Parameterwaarden

nbucket
Het bucketnummer.

Opmerkingen

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

Voorbeeld

// 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

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

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

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

Parameterwaarden

keyval
Sleutelwaarde om naar te zoeken.

Opmerkingen

De lidfunctie retourneert een paar iterators X zodanig dat [X.first, X.second) alleen de elementen van de gecontroleerde reeks met gelijkwaardige volgorde met keyvalscheidingstekens. Als er geen dergelijke elementen bestaan, worden beide iterators end().

Voorbeeld

// 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

Hiermee verwijdert u een element of een reeks elementen in een unordered_set opgegeven positie of verwijdert u elementen die overeenkomen met een opgegeven sleutel.

iterator erase(const_iterator Where);

iterator erase(const_iterator First, const_iterator Last);

size_type erase(const key_type& Key);

Parameterwaarden

Where
Positie van het element dat moet worden verwijderd.

First
Positie van het eerste element dat moet worden verwijderd.

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

Key
De sleutelwaarde van de elementen die moeten worden verwijderd.

Retourwaarde

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

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

Opmerkingen

Zie set::erase voor een codevoorbeeld.

find

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

const_iterator find(const Key& keyval) const;

Parameterwaarden

keyval
Sleutelwaarde om naar te zoeken.

Opmerkingen

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

Voorbeeld

// 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

Hiermee haalt u het opgeslagen allocatorobject op.

Alloc get_allocator() const;

Opmerkingen

De lidfunctie retourneert het opgeslagen allocator-object.

Voorbeeld

// 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

Hiermee haalt u het opgeslagen hash-functieobject op.

Hash hash_function() const;

Opmerkingen

De lidfunctie retourneert het opgeslagen hash-functieobject.

Voorbeeld

// 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

Het type hash-functie.

typedef Hash hasher;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Hash.

Voorbeeld

// 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

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

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

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

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

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

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

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

Parameterwaarden

Val
De waarde van een element dat moet worden ingevoegd in het unordered_set element, tenzij het al een element bevat waarvan de sleutel equivalent is gerangschikt.

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

ValTy
Sjabloonparameter die het argumenttype aangeeft dat de unordered_set parameter kan gebruiken om een element van value_typeen perfect doorsturen Val als argument samen te stellen.

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

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

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

IList
De initializer_list waaruit de elementen moeten worden gekopieerd.

Retourwaarde

De functies met één element, (1) en (2), retourneren een waarvan het pairbool onderdeel waar is als er een invoeging is gemaakt en onwaar als het al een element bevat waarvan de unordered_set sleutel een equivalente waarde in de volgorde had. Het iteratoronderdeel van het retourwaardepaar verwijst naar het zojuist ingevoegde element als het bool onderdeel trueis, of naar het bestaande element als het bool onderdeel is false.

De functies met één element-met-hintlid, (3) en (4), retourneren een iterator die verwijst naar de positie waar het nieuwe element is ingevoegd in de unordered_set of, als er al een element met een equivalente sleutel bestaat, op het bestaande element.

Opmerkingen

Er worden geen iterators, aanwijzers of verwijzingen ongeldig gemaakt door deze functie.

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

Als u toegang wilt krijgen tot het iterator-onderdeel van een pairpr onderdeel dat wordt geretourneerd door de functies van één element, gebruikt pr.firstu ; om de iterator binnen het geretourneerde paar te deducteren, gebruikt*pr.first u, zodat u een element krijgt. Gebruik boolom toegang te krijgen tot het pr.second-onderdeel. Zie de voorbeeldcode verderop in dit artikel voor een voorbeeld.

Het value_type type van een container is een typedef die deel uitmaakt van de container en, voor de set, unordered_set<V>::value_type het type const Vis.

Met de functie bereiklid (5) wordt de volgorde van elementwaarden ingevoegd in een unordered_set element dat overeenkomt met elk element dat wordt geadresseerd door een iterator in het bereik [First, Last); wordt daarom Last niet ingevoegd. De functie containerlid end() verwijst naar de positie vlak na het laatste element in de container, bijvoorbeeld de instructie s.insert(v.begin(), v.end()); probeert alle elementen van v in sin te voegen. Alleen elementen met unieke waarden in het bereik worden ingevoegd; duplicaten worden genegeerd. Als u wilt zien welke elementen worden geweigerd, gebruikt u de versies van één element van insert.

De initialisatielijstlidfunctie (6) maakt gebruik van een initializer_list functie om elementen naar het unordered_setbestand te kopiëren.

Zie set::emplace en set::emplace_hintvoor het invoegen van een element dat op zijn plaats is gebouwd, dat wil gezegd, geen kopieer- of verplaatsingsbewerkingen worden uitgevoerd.

Zie set::insertvoor een codevoorbeeld.

iterator

Een type dat een constante iterator biedt die elementen in een unordered_set kan lezen.

typedef implementation-defined iterator;

Voorbeeld

Zie het voorbeeld voor begin een voorbeeld van het declareren en gebruiken van een iterator.

key_eq

Hiermee haalt u het opgeslagen vergelijkingsfunctieobject op.

Pred key_eq() const;

Opmerkingen

De lidfunctie retourneert het opgeslagen vergelijkingsfunctieobject.

Voorbeeld

// 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

Het type vergelijkingsfunctie.

typedef Pred key_equal;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Pred.

Voorbeeld

// 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

Het type bestelsleutel.

typedef Key key_type;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Key.

Voorbeeld

// 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

Telt de gemiddelde elementen per bucket.

float load_factor() const;

Opmerkingen

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

Voorbeeld

// 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

Het type bucket-iterator.

typedef T4 local_iterator;

Opmerkingen

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

Voorbeeld

// std__unordered_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

Hiermee haalt u het maximum aantal buckets op.

size_type max_bucket_count() const;

Opmerkingen

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

Voorbeeld

// std__unordered_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

Hiermee worden de maximumelementen per bucket opgehaald of ingesteld.

float max_load_factor() const;

void max_load_factor(float factor);

Parameterwaarden

factor
De nieuwe maximale belastingsfactor.

Opmerkingen

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

Voorbeeld

// std__unordered_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

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

size_type max_size() const;

Opmerkingen

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

Voorbeeld

// std__unordered_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=

Kopieert een hash-tabel.

unordered_set& operator=(const unordered_set& right);

unordered_set& operator=(unordered_set&& right);

Parameterwaarden

right
De unordered_set worden gekopieerd naar de unordered_set.

Opmerkingen

Na het wissen van bestaande elementen in een unordered_set, kopieert operator= of verplaatst u de inhoud ervan right naar de unordered_set.

Voorbeeld

// 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

Het type aanwijzer naar een element.

typedef Alloc::pointer pointer;

Opmerkingen

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

Voorbeeld

// std__unordered_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

Het type verwijzing naar een element.

typedef Alloc::reference reference;

Opmerkingen

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

Voorbeeld

// std__unordered_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

Hiermee wordt de hash-tabel opnieuw opgebouwd.

void rehash(size_type nbuckets);

Parameterwaarden

nbuckets
Het aangevraagde aantal buckets.

Opmerkingen

De lidfunctie wijzigt het aantal buckets dat ten minste nbuckets is en herbouwt de hash-tabel indien nodig.

Voorbeeld

// 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

Telt het aantal elementen.

size_type size() const;

Opmerkingen

De lidfunctie retourneert de lengte van de gecontroleerde reeks.

Voorbeeld

// 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

Het type niet-ondertekende afstand tussen twee elementen.

typedef T2 size_type;

Opmerkingen

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

Voorbeeld

// std__unordered_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

Hiermee wordt de inhoud van twee containers gewisseld.

void swap(unordered_set& right);

Parameterwaarden

right
De container waarmee moet worden gewisseld.

Opmerkingen

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

Voorbeeld

// std__unordered_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

Maakt een containerobject.

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

Parameterwaarden

InputIterator
Het type iterator.

Al
Het allocatorobject dat moet worden opgeslagen.

Comp
Het vergelijkingsfunctieobject dat moet worden opgeslagen.

Hash
Het hash-functieobject dat moet worden opgeslagen.

bucket_count
Het minimum aantal buckets.

Right
De container die moet worden gekopieerd.

IList
Het initializer_list met de elementen die moeten worden gekopieerd.

Opmerkingen

De eerste constructor geeft een kopie van de reeks die wordt beheerd door Right. De tweede constructor geeft een lege gecontroleerde reeks aan. De derde constructor geeft een kopie van de reeks op door de vierde tot en met de achtste constructors te verplaatsen Right , gebruikt een initializer_list om de elementen op te geven die moeten worden gekopieerd. De negende constructor voegt de reeks elementwaarden [first, last)in.

Alle constructors initialiseren ook verschillende opgeslagen waarden. Voor de kopieerconstructor worden de waarden verkregen uit Right. Anders:

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

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

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

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

value_type

Het type element.

typedef Key value_type;

Opmerkingen

Het type beschrijft een element van de gecontroleerde reeks.

Voorbeeld

// 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]