deduction guides for 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)
Ableitungsregeln (C++17)

 

Definiert in Header <unordered_set>
template<     class InputIt,     class Hash = std::hash<typename std::iterator_traits<InputIt>::value_type>,     class Pred = std::equal_to<typename std::iterator_traits<InputIt>::value_type>,     class Alloc = std::allocator<typename std::iterator_traits<InputIt>::value_type> > unordered_set( InputIt, InputIt,                typename /* siehe unten */::size_type = /* siehe unten */,                Hash = Hash(), Pred = Pred(), Alloc = Alloc() )     -> unordered_set<typename std::iterator_traits<InputIt>::value_type,                      Hash, Pred, Alloc>;	(1)	(seit C++17)
template< class T,           class Hash = std::hash<T>,           class Pred = std::equal_to<T>,           class Alloc = std::allocator<T> > unordered_set( std::initializer_list<T>,                typename /* siehe unten */::size_type = /* siehe unten */,                Hash = Hash(), Pred = Pred(), Alloc = Alloc() )     -> unordered_set<T, Hash, Pred, Alloc>;	(2)	(seit C++17)
template< class InputIt, class Alloc > unordered_set( InputIt, InputIt, typename /* siehe unten */::size_type, Alloc )     -> unordered_set<typename std::iterator_traits<InputIt>::value_type,                      std::hash<typename std::iterator_traits<InputIt>::value_type>,                      std::equal_to<typename std::iterator_traits<InputIt>::value_type>,                      Alloc>;	(3)	(seit C++17)
template< class InputIt, class Hash, class Alloc > unordered_set( InputIt, InputIt, typename /* siehe unten */::size_type, Hash, Alloc )     -> unordered_set<typename std::iterator_traits<InputIt>::value_type, Hash,                      std::equal_to<typename std::iterator_traits<InputIt>::value_type>,                      Alloc>;	(4)	(seit C++17)
template< class T, class Alloc > unordered_set( std::initializer_list<T>, typename /* siehe unten */::size_type, Alloc )     -> unordered_set<T, std::hash<T>, std::equal_to<T>, Alloc>;	(5)	(seit C++17)
template< class T, class Hash, class Alloc > unordered_set( std::initializer_list<T>, typename /* siehe unten */::size_type,                Hash, Alloc )     -> unordered_set<T, Hash, std::equal_to<T>, Alloc>;	(6)	(seit C++17)
template< ranges::input_range R,           class Hash = std::hash<ranges::range_value_t<R>>,           class Pred = std::equal_to<ranges::range_value_t<R>>,           class Alloc = std::allocator<ranges::range_value_t<R>> > unordered_set( std::from_range_t, R&&,                typename /* siehe unten */::size_type = /* siehe unten */,                Hash = Hash(), Pred = Pred(), Alloc = Alloc() )     -> unordered_set<ranges::range_value_t<R>, Hash, Pred, Alloc>;	(7)	(seit C++23)
template< ranges::input_range R, class Alloc > unordered_set( std::from_range_t, R&&,                typename /* siehe unten */::size_type, Alloc )     -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,                      std::equal_to<ranges::range_value_t<R>>, Alloc>;	(8)	(seit C++23)
template< ranges::input_range R, class Alloc > unordered_set( std::from_range_t, R&&, Alloc )     -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,                      std::equal_to<ranges::range_value_t<R>>, Alloc>;	(9)	(seit C++23)
template< ranges::input_range R, class Hash, class Alloc > unordered_set( std::from_range_t, R&&,                typename /* siehe unten */::size_type, Hash, Alloc )     -> unordered_set<ranges::range_value_t<R>, Hash,                      std::equal_to<ranges::range_value_t<R>>, Alloc>;	(10)	(seit C++23)

1-6) Diese Deduktionshilfen werden für unordered_set bereitgestellt, um die Deduktion aus einem Iterator-Bereich (Überladungen (1,3,4)) und std::initializer_list (Überladungen (2,5,6)) zu ermöglichen. Diese Überladung nimmt nur an der Auflösung von Überladungen teil, wenn InputIt LegacyInputIterator erfüllt, Alloc Allocator erfüllt, weder Hash noch Pred Allocator erfüllen und Hash kein ganzzahliger Typ ist.

7-10) Diese Deduktionshilfen werden für unordered_set bereitgestellt, um die Deduktion aus einem std::from_range_t Tag und einem input_range zu ermöglichen.

Hinweis: Der Umfang, in dem die Bibliothek bestimmt, dass ein Typ LegacyInputIterator nicht erfüllt, ist nicht spezifiziert, außer dass ganzzahlige Typen als Eingabe-Iteratoren nicht qualifiziert sind. Ebenso ist der Umfang, in dem bestimmt wird, dass ein Typ Allocator nicht erfüllt, nicht spezifiziert, außer dass als Minimum der Mitgliedstyp Alloc::value_type existieren muss und der Ausdruck std::declval<Alloc&>().allocate(std::size_t{}) gut gebildet sein muss, wenn er als unevaluierter Operand behandelt wird.

Der size_type-Parametertyp in diesen Leitfäden bezieht sich auf den size_type-Mitgliedstyp des von der Deduktionshilfe abgeleiteten Typs.

Anmerkungen

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_containers_ranges	202202L	(C++23)	Ranges-bewusste Konstruktion und Einfügung; Überladungen (7-10)

Beispiel

Führen Sie diesen Code aus

#include <unordered_set>
 
int main()
{
    // guide #2 deduces std::unordered_set<int>
    std::unordered_set s = {1, 2, 3, 4};
 
    // guide #1 deduces std::unordered_set<int>
    std::unordered_set s2(s.begin(), s.end());
}