deduction guides für std::unordered_multiset

 

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_multiset

Membertypen
Memberfunktionen
unordered_multiset::unordered_multiset unordered_multiset::~unordered_multiset    unordered_multiset::operator= unordered_multiset::get_allocator Iteratoren unordered_multiset::beginunordered_multiset::cbegin unordered_multiset::endunordered_multiset::cend Kapazität unordered_multiset::size unordered_multiset::max_size unordered_multiset::empty Modifizierer unordered_multiset::clear unordered_multiset::insert unordered_multiset::insert_range (C++23) unordered_multiset::emplace unordered_multiset::emplace_hint unordered_multiset::erase unordered_multiset::swap unordered_multiset::extract (C++17) unordered_multiset::merge (C++17)	Suche unordered_multiset::count unordered_multiset::find unordered_multiset::contains (C++20) unordered_multiset::equal_range Bucket-Schnittstelle unordered_multiset::begin(size_type)unordered_multiset::cbegin(size_type) unordered_multiset::end(size_type)unordered_multiset::cend(size_type) unordered_multiset::bucket_count unordered_multiset::max_bucket_count unordered_multiset::bucket_size unordered_multiset::bucket Hash-Politik unordered_multiset::load_factor unordered_multiset::max_load_factor unordered_multiset::rehash unordered_multiset::reserve Observer unordered_multiset::hash_function unordered_multiset::key_eq
Nicht-Member-Funktionen
operator==operator!= (bis C++20)	std::swap(std::unordered_multiset) erase_if(std::unordered_multiset) (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_multiset( InputIt, InputIt,                     typename /* siehe unten */::size_type = /* siehe unten */,                     Hash = Hash(), Pred = Pred(), Alloc = Alloc() )     -> unordered_multiset<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_multiset( std::initializer_list<T>,                     typename /* siehe unten */::size_type = /* siehe unten */,                     Hash = Hash(), Pred = Pred(), Alloc = Alloc() )     -> unordered_multiset<T, Hash, Pred, Alloc>;	(2)	(seit C++17)
template< class InputIt, class Alloc > unordered_multiset( InputIt, InputIt, typename /* siehe unten */::size_type, Alloc )     -> unordered_multiset<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_multiset( InputIt, InputIt, typename /* siehe unten */::size_type, Hash, Alloc )     -> unordered_multiset<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_multiset( std::initializer_list<T>, typename /* siehe unten */::size_type, Alloc )     -> unordered_multiset<T, std::hash<T>, std::equal_to<T>, Alloc>;	(5)	(seit C++17)
template< class T, class Hash, class Alloc > unordered_multiset( std::initializer_list<T>, typename /* siehe unten */::size_type,                     Hash, Alloc )     -> unordered_multiset<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_multiset( std::from_range_t, R&&,                     typename /* siehe unten */::size_type = /* siehe unten */,                     Hash = Hash(), Pred = Pred(), Alloc = Alloc() )     -> unordered_multiset<ranges::range_value_t<R>, Hash, Pred, Alloc>;	(7)	(seit C++23)
template< ranges::input_range R, class Alloc > unordered_multiset( std::from_range_t, R&&,                     typename /* siehe unten */::size_type, Alloc )     -> unordered_multiset<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_multiset( std::from_range_t, R&&, Alloc )     -> unordered_multiset<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_multiset( std::from_range_t, R&&,                     typename /* siehe unten */::size_type, Hash, Alloc )     -> unordered_multiset<ranges::range_value_t<R>, Hash,                           std::equal_to<ranges::range_value_t<R>>, Alloc>;	(10)	(seit C++23)

1-6) Diese deduction guides werden für unordered_multiset 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ösungsfindung teil, wenn InputIt LegacyInputIterator erfüllt, Alloc Allocator erfüllt, weder Hash noch Pred Allocator erfüllen und Hash kein integraler Typ ist.

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

Hinweis: Der Umfang, bis zu dem die Bibliothek feststellt, dass ein Typ LegacyInputIterator nicht erfüllt, ist nicht spezifiziert, außer dass als Minimum integrale Typen nicht als Eingabe-Iteratoren qualifizieren. Ebenso ist der Umfang, bis zu dem sie feststellt, dass ein Typ Allocator nicht erfüllt, nicht spezifiziert, außer dass als Minimum der Member-Typ Alloc::value_type existieren muss und der Ausdruck std::declval<Alloc&>().allocate(std::size_t{}) gutgeformt sein muss, wenn er als nicht ausgewerteter Operand behandelt wird.

Der Parameter `size_type` in diesen Guides bezieht sich auf den `size_type`-Member-Typ des Typs, der vom Deduction Guide abgeleitet wird.

Anmerkungen

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

Beispiel

Führen Sie diesen Code aus

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