std::unordered_set

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::unordered_set

Membertypen
Memberfunktionen
unordered_set::unordered_set unordered_set::~unordered_set unordered_set::operator= unordered_set::get_allocator Iteratoren unordered_set::beginunordered_set::cbegin unordered_set::endunordered_set::cend Kapazität unordered_set::size unordered_set::max_size unordered_set::empty Modifizierer unordered_set::clear unordered_set::erase unordered_set::swap unordered_set::extract (C++17) unordered_set::merge (C++17) unordered_set::insert unordered_set::insert_range (C++23)   unordered_set::emplace unordered_set::emplace_hint	Suche unordered_set::count unordered_set::find unordered_set::contains (C++20) unordered_set::equal_range Bucket-Schnittstelle unordered_set::begin(size_type)unordered_set::cbegin(size_type) unordered_set::end(size_type)unordered_set::cend(size_type) unordered_set::bucket_count unordered_set::max_bucket_count unordered_set::bucket_size unordered_set::bucket Hash-Politik unordered_set::load_factor unordered_set::max_load_factor unordered_set::rehash unordered_set::reserve Observer unordered_set::hash_function unordered_set::key_eq
Nicht-Member-Funktionen
operator==operator!= (bis C++20)	std::swap(std::unordered_set) erase_if(std::unordered_set) (C++20)
Abzugsleitfäden (C++17)

 

Definiert in Header <unordered_set>
template<     class Key,     class Hash = std::hash<Key>,     class KeyEqual = std::equal_to<Key>,     class Allocator = std::allocator<Key> > class unordered_set;	(1)	(seit C++11)
namespace pmr {     template<         class Key,         class Hash = std::hash<Key>,         class Pred = std::equal_to<Key>     > using unordered_set = std::unordered_set<Key, Hash, Pred,                                 std::pmr::polymorphic_allocator<Key>>; }	(2)	(seit C++17)

std::unordered_set ist ein assoziativer Container, der eine Menge eindeutiger Objekte vom Typ Key enthält. Suchen, Einfügen und Entfernen haben eine durchschnittliche konstante Zeitkomplexität.

Intern sind die Elemente nicht in irgendeiner bestimmten Reihenfolge sortiert, sondern in Buckets organisiert. Welchen Bucket ein Element erhält, hängt vollständig vom Hash seines Wertes ab. Dies ermöglicht einen schnellen Zugriff auf einzelne Elemente, da nach der Berechnung eines Hashs dieser auf den exakten Bucket verweist, in den das Element platziert wurde.

Container-Elemente können nicht modifiziert werden (auch nicht durch nicht-const Iteratoren), da eine Modifikation den Hash eines Elements ändern und den Container beschädigen könnte.

std::unordered_set erfüllt die Anforderungen von Container, AllocatorAwareContainer, UnorderedAssociativeContainer.

Alle Memberfunktionen von std::unordered_set sind constexpr: Es ist möglich, std::unordered_set-Objekte während der Auswertung eines konstanten Ausdrucks zu erstellen und zu verwenden. Jedoch können std::unordered_set-Objekte im Allgemeinen nicht constexpr sein, da jeder dynamisch zugewiesene Speicher im selben konstanten Ausdruck freigegeben werden muss.

(seit C++26)

Iterator-Ungültigkeit

Operationen	Invalidiert
Alle schreibgeschützten Operationen, swap, std::swap	Niemals
clear, rehash, reserve, operator=	Immer
insert, emplace, emplace_hint	Nur wenn Rehash ausgelöst wird
erase	Nur für das gelöschte Element

Anmerkungen

• Die Swap-Funktionen machen keine der Iteratoren innerhalb des Containers ungültig, machen aber den Iterator, der das Ende des Swap-Bereichs markiert, ungültig.

• Referenzen und Zeiger auf im Container gespeicherte Daten werden nur durch das Löschen dieses Elements ungültig gemacht, auch wenn der entsprechende Iterator ungültig wird.

• Nach der Move-Zuweisung des Containers, es sei denn, die Element-weise Move-Zuweisung wird durch inkompatible Allokatoren erzwungen, bleiben Referenzen, Zeiger und Iteratoren (außer dem Past-the-End-Iterator) des bewegten Containers gültig, verweisen aber auf Elemente, die sich nun in *this befinden.

Member-Typen

Typ	Definition
key_type	Key
value_type	Key
size_type	Vorzeichenloser Ganzzahltyp (normalerweise std::size_t)
difference_type	Vorzeichenbehafteter Ganzzahltyp (normalerweise std::ptrdiff_t)
hasher	Hash
key_equal	KeyEqual
allocator_type	Allocator
Referenz	value_type&
const_reference	const value_type&
Zeiger	std::allocator_traits<Allocator>::pointer
const_pointer	std::allocator_traits<Allocator>::const_pointer
iterator	Konstante LegacyForwardIterator und ConstexprIterator(seit C++26) zu value_type
const_iterator	LegacyForwardIterator und ConstexprIterator(seit C++26) zu const value_type
local_iterator	Ein Iterator-Typ, dessen Kategorie, Wert, Differenz, Zeiger und Referenztypen dieselben sind wie bei iterator. Dieser Iterator kann verwendet werden, um durch einen einzelnen Bucket zu iterieren, aber nicht über Buckets hinweg
const_local_iterator	Ein Iterator-Typ, dessen Kategorie, Wert, Differenz, Zeiger und Referenztypen dieselben sind wie bei const_iterator. Dieser Iterator kann verwendet werden, um durch einen einzelnen Bucket zu iterieren, aber nicht über Buckets hinweg
node_type (seit C++17)	eine Spezialisierung von node handle, die einen Containerknoten repräsentiert
insert_return_type (seit C++17)	Typ, der das Ergebnis des Einfügens eines node_type beschreibt, eine Spezialisierung von template<class Iter, class NodeType> struct /*unspecified*/ {     Iter     position;     bool     inserted;     NodeType node; }; instanziiert mit den Template-Argumenten iterator und node_type.

Memberfunktionen

(Konstruktor)	konstruiert den unordered_set (public member function)
(Destruktor)	destruiert den unordered_set (public member function)
operator=	weist dem Container Werte zu (public member function)
get_allocator	gibt den zugehörigen Allocator zurück (public member function)
Iteratoren
begincbegin	gibt einen Iterator zum Anfang zurück (public member function)
endcend	gibt einen Iterator zum Ende zurück (public member function)
Kapazität
empty	prüft, ob der Container leer ist (public member function)
size	Gibt die Anzahl der Elemente zurück (public member function)
max_size	Gibt die maximal mögliche Anzahl von Elementen zurück (public member function)
Modifizierer
clear	leert den Inhalt (public member function)
insert	fügt Elemente ein oder Knoten(seit C++17) (public member function)
insert_range (C++23)	fügt einen Bereich von Elementen ein (public member function)
emplace	konstruiert Elemente direkt (in-place) (public member function)
emplace_hint	konstruiert Elemente "in place" unter Verwendung eines Hinweises (public member function)
erase	entfernt Elemente (public member function)
swap	tauscht die Inhalte (public member function)
extract (C++17)	extrahiert Knoten aus dem Container (public member function)
merge (C++17)	fügt Knoten aus einem anderen Container zusammen (public member function)
Suche
zählt	gibt die Anzahl der Elemente zurück, die einem bestimmten Schlüssel entsprechen (public member function)
find	sucht ein Element mit einem bestimmten Schlüssel (public member function)
contains (C++20)	prüft, ob der Container ein Element mit einem bestimmten Schlüssel enthält (public member function)
equal_range	gibt den Bereich von Elementen zurück, die einem bestimmten Schlüssel entsprechen (public member function)
Bucket-Schnittstelle
begin(size_type)cbegin(size_type)	gibt einen Iterator zum Anfang des angegebenen Buckets zurück (public member function)
end(size_type)cend(size_type)	gibt einen Iterator zum Ende des angegebenen Buckets zurück (public member function)
bucket_count	gibt die Anzahl der Buckets zurück (public member function)
max_bucket_count	gibt die maximale Anzahl von Buckets zurück (public member function)
bucket_size	gibt die Anzahl der Elemente in einem bestimmten Bucket zurück (public member function)
bucket	gibt den Bucket für einen bestimmten Schlüssel zurück (public member function)
Hash-Politik
load_factor	gibt die durchschnittliche Anzahl von Elementen pro Bucket zurück (public member function)
max_load_factor	verwaltet die maximale durchschnittliche Anzahl von Elementen pro Bucket (public member function)
rehash	reserviert mindestens die angegebene Anzahl von Buckets und generiert die Hashtabelle neu (public member function)
reserve	reserviert Speicher für mindestens die angegebene Anzahl von Elementen und generiert die Hashtabelle neu (public member function)
Observer
hash_function	gibt die zum Hashen der Schlüssel verwendete Funktion zurück (public member function)
key_eq	gibt die zum Vergleichen von Schlüsseln auf Gleichheit verwendete Funktion zurück (public member function)

Nicht-Member-Funktionen

operator==operator!= (C++11)(C++11)(entfernt in C++20)	vergleicht die Werte im unordered_set (function template)
std::swap(std::unordered_set) (C++11)	spezialisiert den Algorithmus std::swap (function template)
erase_if(std::unordered_set) (C++20)	entfernt alle Elemente, die bestimmte Kriterien erfüllen (function template)

Deduction Guides

(seit C++17)

Anmerkungen

Die Member-Typen iterator und const_iterator können Aliase für denselben Typ sein. Das bedeutet, dass die Definition eines Paares von Funktionsüberladungen, die die beiden Typen als Parametertypen verwenden, die Ein-Definitionen-Regel (ODR) verletzen kann. Da iterator in const_iterator konvertierbar ist, funktioniert stattdessen eine einzelne Funktion mit einem const_iterator als Parametertyp.

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_containers_ranges	202202L	(C++23)	Bereichskonstruktion und -einfügung für Container
__cpp_lib_constexpr_containers	202502L	(C++26)	constexpr std::unordered_set

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <unordered_set>
 
void print(const auto& set)
{
    for (const auto& elem : set)
        std::cout << elem << ' ';
    std::cout << '\n';
}
 
int main()
{
    std::unordered_set<int> mySet{2, 7, 1, 8, 2, 8}; // creates a set of ints
    print(mySet);
 
    mySet.insert(5); // puts an element 5 in the set
    print(mySet);
 
    if (auto iter = mySet.find(5); iter != mySet.end())
        mySet.erase(iter); // removes an element pointed to by iter
    print(mySet);
 
    mySet.erase(7); // removes an element 7
    print(mySet);
}

Mögliche Ausgabe

8 1 7 2
5 8 1 7 2
8 1 7 2
8 1 2

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 2050	C++11	die Definitionen von reference, const_reference, pointer und const_pointer basierten auf allocator_type	basierend auf value_type und std::allocator_traits

Siehe auch

unordered_multiset (C++11)	Sammlung von Schlüsseln, gehasht nach Schlüsseln (Klassenvorlage)
setzt	Sammlung eindeutiger Schlüssel, sortiert nach Schlüsseln (Klassenvorlage)
flat_set (C++23)	passt einen Container an, um eine Sammlung eindeutiger Schlüssel, sortiert nach Schlüsseln, bereitzustellen (Klassenvorlage)