Namespaces
Variants

deduction guides for std::unordered_set

From cppreference.net

C++
Containers library
std::unordered_set
Member types
Member functions
Non-member functions
Deduction guides (C++17)
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur wurde gemäß den Anforderungen unverändert beibehalten.)
Definiert im 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 Deduktionsführer werden für unordered_set bereitgestellt, um die Deduktion aus einem Iteratorbereich (Überladungen (1,3,4) ) und std::initializer_list (Überladungen (2,5,6) ) zu ermöglichen. Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn InputIt die Anforderungen eines LegacyInputIterator erfüllt, Alloc die Anforderungen eines Allocator erfüllt, weder Hash noch Pred die Anforderungen eines Allocator erfüllen und Hash kein integraler Typ ist.
7-10) Diese Deduktionsführer werden für unordered_set bereitgestellt, um die Deduktion aus einem std::from_range_t -Tag und einem input_range zu ermöglichen.

Hinweis: Das Ausmaß, in dem die Bibliothek feststellt, dass ein Typ nicht die Anforderungen eines LegacyInputIterator erfüllt, ist nicht spezifiziert, außer dass mindestens integrale Typen nicht als Input-Iteratoren qualifizieren. Ebenso ist das Ausmaß, in dem sie feststellt, dass ein Typ nicht die Anforderungen eines Allocator erfüllt, nicht spezifiziert, außer dass mindestens der Member-Typ Alloc::value_type existieren muss und der Ausdruck std:: declval < Alloc & > ( ) . allocate ( std:: size_t { } ) wohlgeformt sein muss, wenn er als nicht ausgewerteter Operand behandelt wird.

Der size_type -Parametertyp in diesen Leitfäden bezieht sich auf den size_type -Membertyp des durch den Deduktionsleitfaden abgeleiteten Typs.

Hinweise

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

Beispiel

Diesen Code ausführen 
#include <unordered_set>
int main()
{
    // Guide #2 leitet std::unordered_set<int> ab
    std::unordered_set s = {1, 2, 3, 4};
    // Guide #1 leitet std::unordered_set<int> ab
    std::unordered_set s2(s.begin(), s.end());
}