`unordered_set`-Klasse

Artikel
10/12/2023

Die Klassenvorlage beschreibt ein Objekt, das eine unterschiedliche Abfolge von Elementen vom Typ const Keysteuert. Die Sequenz wird grob durch eine Hashfunktion sortiert, die die Sequenz in eine geordnete Gruppe von Untersequenzen, so genannte Buckets, unterteilt. Innerhalb jedes Buckets bestimmt eine Vergleichsfunktion, ob ein Elementpaar eine gleichwertige Sortierung aufweist. Jedes Element dient sowohl als Sortierschlüssel als auch als Wert. Die Sequenz wird so dargestellt, dass die Suche, das Einfügen und das Entfernen eines beliebigen Elements mit einer Reihen von Vorgängen möglich ist, die unabhängig von der Anzahl von Elementen in der Sequenz (konstante Zeit) sein können, zumindest, wenn alle Buckets von ungefähr gleicher Länge sind. Im schlimmsten Fall, d. h., wenn sich alle Elemente in einem Bucket befinden, ist die Anzahl von Vorgängen proportional zur Anzahl von Elementen in der Sequenz (lineare Zeit). Durch das Einfügen eines Elements werden keine Iteratoren ungültig, und durch das Entfernen eines Elements werden nur die Iteratoren ungültig, die auf das entfernte Element zeigen.

Syntax

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

Parameter

Key
Der Schlüsseltyp.

Hash
Der Hashfunktionsobjekttyp.

Pred
Der Gleichheitsvergleich-Funktionsobjekttyp.

Alloc
Die Zuweisungsklasse.

Member

TypeDefs

Name	Beschreibung
`allocator_type`	Der Typ einer Zuweisung für die Speicherverwaltung.
`const_iterator`	Der Typ eines konstanten Iterators für die gesteuerte Sequenz.
`const_local_iterator`	Der Typ eines konstanten Bucketiterators für die gesteuerte Sequenz.
`const_pointer`	Der Typ eines konstanten Zeigers auf ein Element.
`const_reference`	Der Typ eines konstanten Verweises auf ein Element.
`difference_type`	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
`hasher`	Der Typ der Hashfunktion.
`iterator`	Der Typ eines Iterators für die gesteuerte Sequenz.
`key_equal`	Der Typ der Vergleichsfunktion.
`key_type`	Der Typ eines Sortierschlüssels.
`local_iterator`	Der Typ eines Bucketiterators für die gesteuerte Sequenz.
`pointer`	Der Typ eines Zeigers auf ein Element.
`reference`	Der Typ eines Verweises auf ein Element.
`size_type`	Der Typ eines Abstands ohne Vorzeichen zwischen zwei Elementen.
`value_type`	Der Typ eines Elements.

Functions

Name	Beschreibung
`begin`	Legt den Anfang der kontrollierten Sequenz fest.
`bucket`	Ruft die Bucketnummer für einen Schlüsselwert ab.
`bucket_count`	Ruft die Anzahl von Buckets ab.
`bucket_size`	Ruft die Größe eines Buckets ab.
`cbegin`	Legt den Anfang der kontrollierten Sequenz fest.
`cend`	Legt das Ende der kontrollierten Sequenz fest.
`clear`	Entfernt alle Elemente.
`contains`^C++20	Überprüfen Sie, ob ein Element mit dem angegebenen Schlüssel in der .`unordered_set`
`count`	Sucht die Anzahl von Elementen, die einem angegebenen Schlüssel entsprechen.
`emplace`	Fügt ein Element hinzu, das direkt erstellt wird.
`emplace_hint`	Fügt ein Element hinzu, das direkt mit Hinweis erstellt wird.
`empty`	Testet, ob keine Elemente vorhanden sind.
`end`	Legt das Ende der kontrollierten Sequenz fest.
`equal_range`	Sucht den Bereich, der einem angegebenen Schlüssel entspricht.
`erase`	Entfernt Elemente an den angegebenen Positionen.
`find`	Sucht ein Element, das einem angegebenen Schlüssel entspricht.
`get_allocator`	Ruft das gespeicherte Zuweisungsobjekt ab.
`hash_function`	Ruft das gespeicherte Hashfunktionsobjekt ab.
`insert`	Fügt Elemente hinzu.
`key_eq`	Ruft das gespeicherte Vergleichsfunktionsobjekt ab.
`load_factor`	Zählt die durchschnittliche Anzahl von Elementen pro Bucket.
`max_bucket_count`	Ruft die maximale Anzahl von Buckets ab.
`max_load_factor`	Ruft die maximale Anzahl von Elementen pro Bucket ab oder legt sie fest.
`max_size`	Ruft die maximale Größe der gesteuerten Sequenz ab.
`rehash`	Erstellt die Hashtabelle neu.
`size`	Ermittelt die Anzahl von Elementen.
`swap`	Vertauscht den Inhalt von zwei Containern.
`unordered_set`	Erstellt ein container-Objekt.

Operatoren

Name	Beschreibung
`unordered_set::operator=`	Kopiert eine Hashtabelle.

Hinweise

Das Objekt sortiert die Reihenfolge, die es steuert, indem zwei gespeicherte Objekte aufgerufen werden, ein Vergleichsfunktionsobjekt vom Typ unordered_set::key_equal und ein Hashfunktionsobjekt vom Typ unordered_set::hasher. Sie greifen auf das erste gespeicherte Objekt zu, indem Sie die Memberfunktion unordered_set::key_eq()aufrufen; und Sie greifen auf das zweite gespeicherte Objekt zu, indem Sie die Memberfunktion unordered_set::hash_function()aufrufen. Insbesondere für alle Werte X und Y vom Typ Key gibt der Aufruf von key_eq()(X, Y) nur "true" zurück, wenn die beiden Argumentwerte die entsprechende Reihenfolge aufweisen. Der Aufruf von hash_function()(keyval) ergibt eine Verteilung von Werten des Typs size_t. Im Gegensatz zur Klassenvorlagenklasse unordered_multiset stellt ein Objekt vom Typ unordered_set sicher, dass key_eq()(X, Y) für alle zwei Elemente der gesteuerten Sequenz immer "false" festgelegt ist. (Schlüssel sind eindeutig.)

Das Objekt speichert auch einen Höchstlastfaktor, der die maximal erwünschte durchschnittliche Anzahl von Elementen pro Bucket angibt. Wenn das Einfügen eines Elements unordered_set::load_factor() den maximalen Ladefaktor überschreitet, erhöht der Container die Anzahl der Buckets und erstellt die Hashtabelle nach Bedarf neu.

Die tatsächliche Reihenfolge der Elemente in der gesteuerten Sequenz hängt von der Hashfunktion, von der Vergleichsfunktion, von der Einfügereihenfolge, vom Höchstlastfaktor und von der aktuellen Anzahl von Buckets ab. Im Allgemeinen können Sie die Reihenfolge der Elemente in der kontrollierten Sequenz nicht vorhersagen. Sie können allerdings sicher sein, dass jede Teilmenge von Elementen, die die entsprechende Reihenfolge aufweisen, in der gesteuerten Sequenz benachbart sind.

Das Objekt reserviert und gibt Speicherplatz für die Sequenz frei, die es über ein gespeichertes Allocator-Objekt vom Typ unordered_set::allocator_typesteuert. Ein solches Allocator-Objekt muss dieselbe externe Schnittstelle wie ein Objekt vom Typ allocatoraufweisen. Das gespeicherte Allocator-Objekt wird nicht kopiert, wenn das Containerobjekt zugewiesen wird.

`unordered_set::allocator_type`

Der Typ einer Zuweisung für die Speicherverwaltung.

typedef Alloc allocator_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Allocdar.

Beispiel

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

Kennzeichnet den Anfang der kontrollierten Sequenz oder eines Buckets.

iterator begin();

const_iterator begin() const;

local_iterator begin(size_type nbucket);

const_local_iterator begin(size_type nbucket) const;

Parameter

nbucket
Die Bucketnummer.

Hinweise

Die beiden ersten Memberfunktionen geben einen Vorwärtsiterator zurück, der auf das erste Element der Sequenz zeigt (bzw. unmittelbar hinter das Ende einer leeren Sequenz). Die beiden letzten Memberfunktionen geben einen Vorwärtsiterator zurück, der auf das erste Element des Buckets nbucket zeigt (bzw. unmittelbar hinter das Ende eines leeren Buckets).

Beispiel

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

Ruft die Bucketnummer für einen Schlüsselwert ab.

size_type bucket(const Key& keyval) const;

Parameter

keyval
Der zuzuordnende Schlüsselwert.

Hinweise

Die Memberfunktion gibt die Bucketnummer zurück, die derzeit dem Schlüsselwert keyvalentspricht.

Beispiel

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

Ruft die Anzahl von Buckets ab.

size_type bucket_count() const;

Hinweise

Die Memberfunktion gibt die aktuelle Anzahl von Buckets zurück.

Beispiel

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

Ruft die Größe eines Buckets ab.

size_type bucket_size(size_type nbucket) const;

Parameter

nbucket
Die Bucketnummer.

Hinweise

Die Memberfunktion gibt die Größe von Bucket Nummer nbucketzurück.

Beispiel

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

Gibt einen const-Iterator zurück, mit dem das erste Element im Bereich behandelt wird.

const_iterator cbegin() const;

Rückgabewert

Ein const-Forward-Access-Iterator, der auf das erste Element des Bereichs zeigt oder die Position direkt hinter dem Ende eines leeren Bereichs (für einen leeren Bereich gilt cbegin() == cend()).

Hinweise

Mit dem Rückgabewert von cbegin, die Elemente im Bereich können nicht geändert werden.

Sie können diese Memberfunktion anstelle der begin()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. In der Regel wird sie zusammen mit dem auto Stichwort "Typabzug" verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der begin() und cbegin() unterstützt.

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

// i2 isContainer<T>::const_iterator

`cend`

Gibt einen const-Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines Bereichs unmittelbar nachfolgt.

const_iterator cend() const;

Rückgabewert

Gibt einen const-Forward-Access-Iterator zurück, der auf eine Position unmittelbar nach dem Ende des Bereichs verweist.

Hinweise

cend wird verwendet, um zu testen, ob ein Iterator das Ende seines Bereichs übergeben hat.

Sie können diese Memberfunktion anstelle der end()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. In der Regel wird sie zusammen mit dem auto Stichwort "Typabzug" verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der end() und cend() unterstützt.

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

// i2 isContainer<T>::const_iterator

Der zurückgegebene cend Wert sollte nicht abgeleitet werden.

`clear`

Entfernt alle Elemente.

void clear();

Hinweise

Die Memberfunktion ruft unordered_set::erase( unordered_set::begin(), unordered_set::end()). Weitere Informationen finden Sie unter unordered_set::erase, unordered_set::begin und unordered_set::end.

Beispiel

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

Der Typ eines konstanten Iterators für die gesteuerte Sequenz.

typedef T1 const_iterator;

Hinweise

Der Typ beschreibt ein Objekt, das als konstanter Forward-Iterator für die gesteuerte Sequenz fungieren kann. Es wird hier als Synonym für den implementierungsdefinierte Typ T1beschrieben.

Beispiel

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

Der Typ eines konstanten Bucketiterators für die gesteuerte Sequenz.

typedef T5 const_local_iterator;

Hinweise

Der Typ beschreibt ein Objekt, das als konstanter Vorwärtsiterator für ein Bucket dienen kann. Es wird hier als Synonym für den implementierungsdefinierte Typ T5beschrieben.

Beispiel

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

Der Typ eines konstanten Zeigers auf ein Element.

typedef Alloc::const_pointer const_pointer;

Hinweise

Der Typ beschreibt ein Objekt, das als konstanter Zeiger für ein Element der gesteuerten Sequenz fungieren kann.

Beispiel

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

Der Typ eines konstanten Verweises auf ein Element.

typedef Alloc::const_reference const_reference;

Hinweise

Der Typ beschreibt ein Objekt, das als Konstantenverweis für ein Element der gesteuerten Sequenz fungieren kann.

Beispiel

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

Überprüft, ob ein Element mit dem angegebenen Schlüssel in der unordered_set.

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

Parameter

K
Der Typ des Schlüssels.

Key
Der Schlüsselwert des Elements, nach dem gesucht werden soll.

Rückgabewert

true wenn das Element im Container gefunden wird; false sonst.

Hinweise

contains() ist neu in C++20. Geben Sie zur Verwendung die Compileroption /std:c++20 oder höher an.

template<class K> bool contains(const K& key) const nimmt nur an der Überladungsauflösung teil, wenn key_compare dies transparent ist.

Beispiel

// Requires /std:c++20 or /std:c++latest
#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`

Sucht die Anzahl von Elementen, die einem angegebenen Schlüssel entsprechen.

size_type count(const Key& keyval) const;

Parameter

keyval
Der zu suchende Schlüsselwert.

Hinweise

Die Memberfunktion gibt die Anzahl der Elemente im Bereich zurück, der durch Trennzeichen getrennt ist unordered_set::equal_range(keyval).

Beispiel

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

Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.

typedef T3 difference_type;

Hinweise

Der Ganzzahltyp mit Vorzeichen beschreibt ein Objekt, das die Differenz zwischen den Adressen von zwei beliebigen Elementen in der gesteuerten Sequenz darstellen kann. Es wird hier als Synonym für den implementierungsdefinierte Typ T3beschrieben.

Beispiel

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

Es wird ein Element eingefügt, das vor Ort konstruiert wird (keine Kopieren- oder Verschiebevorgänge werden ausgeführt).

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

Parameter

args
Die Argumente, die weitergeleitet werden, um ein Element zu konstruieren, das in das unordered_set Element eingefügt werden soll, es sei denn, es enthält bereits ein Element, dessen Wert gleichwertig sortiert ist.

Rückgabewert

Ein pair-Element, dessen bool-Komponente "true" zurückgibt, wenn eine Einfügung erfolgt ist und "false", wenn unordered_set bereits ein Element enthält, dessen Schlüssel einen entsprechenden Wert in der Reihenfolge aufweist und dessen Iteratorkomponente die Adresse zurückgibt, an der ein neues Element eingefügt wurde oder, an der das Element bereits gefunden wurde.

Um auf die Iteratorkomponente eines pr-Paares zuzugreifen, das von dieser Memberfunktion zurückgegeben wird, verwenden Sie pr.first und *(pr.first), um es zu dereferenzieren. Um auf die bool-Komponente eines pr-Paares zuzugreifen, das von dieser Memberfunktion zurückgegeben wird, verwenden Sie pr.second.

Hinweise

Durch diese Funktion werden keine Iteratoren oder Verweise ungültig.

Wenn beim Einfügen eine Ausnahme ausgelöst wird, aber nicht in der Hashfunktion des Containers auftritt, wird der Container nicht geändert. Wenn die Ausnahme in der Hashfunktion ausgelöst wird, ist das Ergebnis nicht definiert.

Ein Codebeispiel finden Sie unter set::emplace.

`emplace_hint`

Fügt ein Element mit einem Platzierungshinweis ein, das vor Ort erstellt wird (Es werden keine Kopier- oder Verschiebevorgänge ausgeführt).

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

Parameter

args
Die Argumente, die weitergeleitet werden, um ein Element zu konstruieren, das in das unordered_set Element eingefügt werden soll, es sei denn, das unordered_set Element enthält das Element, es sei denn, es enthält bereits ein Element, dessen Schlüssel gleichwertig sortiert ist.

where
Ein Hinweis auf die Stelle, an der sie mit der Suche nach der richtigen Einfügemarke beginnen soll.

Rückgabewert

Ein Iterator zum neu eingefügten Element.

Wenn die Einfügung fehlerhaft war, da das Element bereits vorhanden ist, wird ein Iterator an das vorhandene Element zurückgegeben.

Hinweise

Durch diese Funktion werden keine Iteratoren oder Verweise ungültig.

Ein Codebeispiel finden Sie unter set::emplace_hint.

`empty`

Testet, ob keine Elemente vorhanden sind.

bool empty() const;

Hinweise

Die Memberfunktion gibt „true“ für eine leere gesteuerte Sequenz zurück.

Beispiel

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

Legt das Ende der kontrollierten Sequenz fest.

iterator end();

const_iterator end() const;

local_iterator end(size_type nbucket);

const_local_iterator end(size_type nbucket) const;

Parameter

nbucket
Die Bucketnummer.

Hinweise

Die ersten beiden Memberfunktionen geben einen Vorwärtsiterator zurück, der direkt hinter das Ende der Sequenz verweist. Die letzten beiden Memberfunktionen geben einen Forward-Iterator zurück, der direkt hinter das Ende von Bucket nbucketzeigt.

Beispiel

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

Sucht den Bereich, der einem angegebenen Schlüssel entspricht.

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

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

Parameter

keyval
Der zu suchende Schlüsselwert.

Hinweise

Die Memberfunktion gibt ein Paar von Iteratoren X zurück, sodass [X.first, X.second) nur die Elemente der gesteuerten Sequenz begrenzt, die eine entsprechende Sortierung mit keyvalaufweisen. Wenn keine solchen Elemente vorhanden sind, sind beide Iteratoren end().

Beispiel

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

Es wird ein Element oder ein Bereich von Elementen in einem unordered_set von angegebenen Speicherorten entfernt, oder es werden die einem angegebenen Schlüssel entsprechenden Elemente entfernt.

iterator erase(const_iterator Where);

iterator erase(const_iterator First, const_iterator Last);

size_type erase(const key_type& Key);

Parameter

Where
Die Position des zu entfernenden Elements.

First
Die Position des ersten zu entfernenden Elements.

Last
Die Position direkt hinter dem letzten zu entfernenden Element.

Key
Der Schlüsselwert der zu entfernenden Elemente.

Rückgabewert

Bei den ersten beiden Memberfunktionen wird ein bidirektionaler Iterator, der das erste Element bestimmt, das über alle entfernten Elemente hinausgeht, oder ein Element, das das Ende des unordered_set Elements darstellt, wenn kein solches Element vorhanden ist.

Gibt für die dritte Memberfunktion die Anzahl der Elemente zurück, die aus dem unordered_setElement entfernt wurden.

Hinweise

Ein Codebeispiel finden Sie unter set::erase.

`find`

Sucht ein Element, das einem angegebenen Schlüssel entspricht.

const_iterator find(const Key& keyval) const;

Parameter

keyval
Der zu suchende Schlüsselwert.

Hinweise

Die Memberfunktion gibt unordered_set::equal_range(keyval).first zurück.

Beispiel

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

Ruft das gespeicherte Zuweisungsobjekt ab.

Alloc get_allocator() const;

Hinweise

Die Memberfunktion gibt das gespeicherte Zuweisungsobjekt zurück.

Beispiel

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

Ruft das gespeicherte Hashfunktionsobjekt ab.

Hash hash_function() const;

Hinweise

Die Memberfunktion gibt das gespeicherte Hashfunktionsobjekt zurück.

Beispiel

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

Der Typ der Hashfunktion.

typedef Hash hasher;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Hashdar.

Beispiel

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

Fügt ein Element oder einen Bereich von Elementen in ein 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);

Parameter

Val
Der Wert eines Elements, das in das unordered_set Element eingefügt werden soll, es sei denn, es enthält bereits ein Element, dessen Schlüssel äquivalent sortiert ist.

Where
Die Position, an dem mit der Suche nach dem richtigen Einfügepunkt begonnen wird.

ValTy
Der Vorlagenparameter, der den Argumenttyp angibt, mit dem unordered_set ein Element erstellt value_typewerden kann, und perfekte Weiterleitungen Val als Argument.

First
Die Position des ersten zu kopierenden Elements.

Last
Die Position direkt über den letzten zu kopierenden Elements.

InputIterator
Vorlagenfunktionsargument, das den Anforderungen eines Eingabe-Iterators entspricht, der auf Elemente eines Typs verweist, die zum Erstellen value_type von Objekten verwendet werden können.

IList
Die initializer_list Elemente, von denen die Elemente kopiert werden sollen.

Rückgabewert

Die Einzelelementfunktionen (1) und (2) geben eine pair Komponente zurück, deren bool Komponente wahr ist, wenn eine Einfügung vorgenommen wurde, und "false", wenn das unordered_set bereits enthaltene Element, dessen Schlüssel einen entsprechenden Wert in der Sortierung aufweist. Die Iteratorkomponente des Rückgabewertpaars verweist auf das neu eingefügte Element, wenn die bool Komponente vorhanden ist true, oder auf das vorhandene Element, wenn die bool Komponente vorhanden ist false.

Die Elementfunktionen für ein einzelnes Element mit Hinweis (3) und (4) geben einen Iterator zurück, der auf die Position zeigt, an der das neue Element in das unordered_set element eingefügt wurde, oder, wenn ein Element mit einem entsprechenden Schlüssel bereits vorhanden ist, an das vorhandene Element.

Hinweise

Durch diese Funktion werden keine Iteratoren, Zeiger oder Verweise ungültig.

Wenn beim Einfügen nur eines Elements eine Ausnahme ausgelöst wird, die aber nicht in der Hashfunktion des Containers auftritt, wird der Containerstatus nicht geändert. Wenn die Ausnahme in der Hashfunktion ausgelöst wird, ist das Ergebnis nicht definiert. Wird beim Einfügen mehrerer Elementen eine Ausnahme ausgelöst, wird der Container in einem nicht angegebenen doch gültigen Zustand belassen.

Um auf die Iteratorkomponente eines pair pr elements zuzugreifen, das von den Einzelelementfunktionen zurückgegeben wird, verwenden Sie ; pr.firstum den Iterator innerhalb des zurückgegebenen Paares abzuleiten, verwenden*pr.first Sie ein Element. Um auf die bool-Komponente zuzugreifen, verwenden Sie pr.second. Eine Beispiel finden Sie unter Beispielcode weiter unten in diesem Artikel.

Der value_type Container ist ein Typedef, der zum Container gehört, und für den Satz unordered_set<V>::value_type ein Typ const Vist.

Die Bereichselementfunktion (5) fügt die Abfolge von Elementwerten in ein unordered_set Element ein, das jedem Element entspricht, das von einem Iterator im Bereich [First, Last)adressiert wird; daher Last wird nicht eingefügt. Die Containermemberfunktion end() bezieht sich auf die Position direkt hinter dem letzten Element im Container. Z. B versucht die Anweisung s.insert(v.begin(), v.end()); alle Elemente von v in s einzufügen. Nur Elemente, die eindeutige Werte im Bereich aufweisen werden eingefügt. Duplikate werden ignoriert. Um zu betrachten welche Elemente abgelehnt werden, verwenden Sie die Einzelelementversionen von insert.

Die Initialisierungslistenelementfunktion (6) verwendet zum initializer_list Kopieren von Elementen in die unordered_set.

Informationen zum Einfügen eines direkt erstellten Elements , d. h. es werden keine Kopier- oder Verschiebungsvorgänge ausgeführt – siehe set::emplace und set::emplace_hint.

Ein Codebeispiel finden Sie unter set::insert.

`iterator`

Ein Typ, der eine konstante Weiterleitungs iterator bereitstellt, die Elemente in einem unordered_set lesen kann.

typedef implementation-defined iterator;

Beispiel

Ein Beispiel zum Deklarieren und Verwenden eines Iterators finden Sie im Beispielbegin.

`key_eq`

Ruft das gespeicherte Vergleichsfunktionsobjekt ab.

Pred key_eq() const;

Hinweise

Die Memberfunktion gibt das gespeicherte Vergleichsfunktionsobjekt zurück.

Beispiel

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

Der Typ der Vergleichsfunktion.

typedef Pred key_equal;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Preddar.

Beispiel

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

Der Typ eines Sortierschlüssels.

typedef Key key_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Keydar.

Beispiel

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

Zählt die durchschnittliche Anzahl von Elementen pro Bucket.

float load_factor() const;

Hinweise

Die Memberfunktion gibt (float)unordered_set::size() / (float)unordered_set::bucket_count() zurück, also die durchschnittliche Anzahl von Elementen pro Bucket.

Beispiel

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

Der Typ eines Bucketiterators.

typedef T4 local_iterator;

Hinweise

Der Typ beschreibt ein Objekt, das als ein Vorwärtsiterator für ein Bucket dienen kann. Es wird hier als Synonym für den implementierungsdefinierte Typ T4beschrieben.

Beispiel

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

Ruft die maximale Anzahl von Buckets ab.

size_type max_bucket_count() const;

Hinweise

Die Memberfunktion gibt die maximale Anzahl von Buckets zurück, die derzeit zulässig ist.

Beispiel

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

Ruft die maximale Anzahl von Elementen pro Bucket ab oder legt sie fest.

float max_load_factor() const;

void max_load_factor(float factor);

Parameter

factor
Der neue maximale Lastfaktor.

Hinweise

Die erste Memberfunktion gibt den gespeicherten maximalen Lastfaktor zurück. Die zweite Memberfunktion ersetzt den gespeicherten maximalen Lastfaktor durch factor.

Beispiel

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

Ruft die maximale Größe der gesteuerten Sequenz ab.

size_type max_size() const;

Hinweise

Die Memberfunktion gibt die Länge der längsten Sequenz zurück, die das Objekt steuern kann.

Beispiel

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

Kopiert eine Hashtabelle.

unordered_set& operator=(const unordered_set& right);

unordered_set& operator=(unordered_set&& right);

Parameter

right
Das unordered_set kopierte In das unordered_set.

Hinweise

Nachdem ein vorhandenes Element in einem unordered_setgelöscht wurde, kopiert oder verschiebt operator= den Inhalt von right in den unordered_set.

Beispiel

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

Der Typ eines Zeigers auf ein Element.

typedef Alloc::pointer pointer;

Hinweise

Der Typ beschreibt ein Objekt, das als Zeiger auf ein Element der gesteuerten Sequenz fungieren kann.

Beispiel

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

Der Typ eines Verweises auf ein Element.

typedef Alloc::reference reference;

Hinweise

Der Typ beschreibt ein Objekt, das als Verweis auf ein Element der gesteuerten Sequenz fungieren kann.

Beispiel

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

Erstellt die Hashtabelle neu.

void rehash(size_type nbuckets);

Parameter

nbuckets
Die angeforderte Anzahl von Buckets.

Hinweise

Die Memberfunktion ändert die Anzahl der Buckets in mindestens nbuckets und erstellt ggf. die Hashtabelle neu.

Beispiel

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

Ermittelt die Anzahl von Elementen.

size_type size() const;

Hinweise

Die Memberfunktion gibt die Länge der gesteuerten Sequenz zurück.

Beispiel

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

Der Typ eines Abstands ohne Vorzeichen zwischen zwei Elementen.

typedef T2 size_type;

Hinweise

Der unsignierte Ganzzahltyp beschreibt ein Objekt, das die Länge jeder kontrollierten Sequenz darstellen kann. Es wird hier als Synonym für den implementierungsdefinierte Typ T2beschrieben.

Beispiel

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

Vertauscht den Inhalt von zwei Containern.

void swap(unordered_set& right);

Parameter

right
Der Container für den Tauschvorgang.

Hinweise

Die Memberfunktion tauscht die kontrollierten Sequenzen zwischen *this und right aus. Wenn unordered_set::get_allocator() == right.get_allocator()dies in konstanter Zeit der Fall ist, löst sie eine Ausnahme nur als Ergebnis des Kopierens des gespeicherten Eigenschaftenobjekts vom Typ Traus, und es ungültigt keine Bezüge, Zeiger oder Iteratoren, die Elemente in den beiden gesteuerten Sequenzen kennzeichnen. Andernfalls führt Sie proportional zur Anzahl der Elemente in den beiden kontrollierten Sequenzen eine Reihe von Elementzuweisungen und Konstruktoraufrufe aus.

Beispiel

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

Erstellt ein container-Objekt.

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

Parameter

InputIterator
Der Iteratortyp.

Al
Das zu speichernde Zuweisungsobjekt.

Comp
Das zu speichernde Vergleichsfunktionsobjekt.

Hash
Das zu speichernde Hashfunktionsobjekt.

bucket_count
Die Mindestanzahl von Buckets.

Right
Der zu kopierende Container.

IList
Die initializer_list elemente, die kopiert werden sollen.

Hinweise

Mit dem ersten Konstruktor wird eine Kopie der Sequenz angegeben, die von Right gesteuert wird. Mit dem zweiten Konstruktor wird eine leere gesteuerte Sequenz angegeben. Der dritte Konstruktor gibt eine Kopie der Sequenz an, indem der vierte bis achte Konstruktor eine initializer_list Kopie der Sequenz verwendetRight, um die zu kopierenden Elemente anzugeben. Mit dem neunten Konstruktor wird die Elementwertesequenz [first, last) eingefügt.

Alle Konstruktoren initialisieren auch einige gespeicherte Werte. Für den Kopierkonstruktor werden die Werte aus Right abgerufen. Ansonsten:

Die minimale Anzahl von Buckets ist das Argument bucket_count, falls vorhanden. Andernfalls handelt es sich um einen Standardwert, der hier als implementierungsdefinierter Wert N0beschrieben wird.

Das Hashfunktionsobjekt ist das Argument Hash, falls vorhanden. Andernfalls ist Hash()es .

Das Vergleichsfunktionsobjekt ist das Argument Comp, falls vorhanden; andernfalls ist Comp()es .

Das Allocator-Objekt ist das Argument Al, falls vorhanden; andernfalls ist Alloc()es .

`value_type`

Der Typ eines Elements.

typedef Key value_type;

Hinweise

Der Typ beschreibt ein Element der gesteuerten Sequenz.

Beispiel

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

Teilen über

unordered_set-Klasse

Syntax

Parameter

Member

TypeDefs

Functions

Operatoren

Hinweise

unordered_set::allocator_type

Hinweise

Beispiel

begin

Parameter

Hinweise

Beispiel

bucket

Parameter

Hinweise

Beispiel

bucket_count

Hinweise

Beispiel

bucket_size

Parameter

Hinweise

Beispiel

cbegin

Rückgabewert

Hinweise

cend

Rückgabewert

Hinweise

clear

Hinweise

Beispiel

const_iterator

Hinweise

Beispiel

const_local_iterator

Hinweise

Beispiel

const_pointer

Hinweise

Beispiel

const_reference

Hinweise

Beispiel

contains

Parameter

Rückgabewert

Hinweise

Beispiel

count

Parameter

Hinweise

Beispiel

difference_type

Hinweise

Beispiel

emplace

Parameter

Rückgabewert

Hinweise

emplace_hint

Parameter

Rückgabewert

Hinweise

empty

Hinweise

Beispiel

end

Parameter

Hinweise

Beispiel

equal_range

Parameter

Hinweise

Beispiel

erase

`unordered_set`-Klasse

`unordered_set::allocator_type`

`begin`

`bucket`

`bucket_count`

`bucket_size`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_local_iterator`

`const_pointer`

`const_reference`

`contains`

`count`

`difference_type`

`emplace`

`emplace_hint`

`empty`

`end`

`equal_range`

`erase`

`find`

`get_allocator`

`hash_function`

`hasher`

`insert`

`iterator`

`key_eq`

`key_equal`

`key_type`

`load_factor`

`local_iterator`

`max_bucket_count`

`max_load_factor`

`max_size`

`operator=`

`pointer`

`reference`

`rehash`

`size`

`size_type`

`swap`