Namespaces
Variants

deduction guides for std::unordered_map

From cppreference.net

C++
Containers library
std::unordered_map
Member types
Member functions
Non-member functions
Deduction guides (C++17)
헤더 파일에 정의됨 <unordered_map>
template < class InputIt,

class Hash = std:: hash < /*iter-key-t*/ < InputIt >> ,
class Pred = std:: equal_to < /*iter-key-t*/ < InputIt >> ,
class Alloc = std:: allocator < /*iter-to-alloc-t*/ < InputIt >> >
unordered_map ( InputIt, InputIt,
typename /* 아래 참조 */ :: size_type = /* 아래 참조 */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )
- > unordered_map < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > ,

Hash, Pred, Alloc > ;
(1) (C++17부터)
template < class Key, class T, class Hash = std:: hash < Key > ,

class Pred = std:: equal_to < Key > ,
class Alloc = std:: allocator < std:: pair < const Key, T >> >
unordered_map ( std:: initializer_list < std:: pair < Key, T >> ,
typename /* 아래 참조 */ :: size_type = /* 아래 참조 */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )

- > unordered_map < Key, T, Hash, Pred, Alloc > ;
(2) (C++17부터)
template < class InputIt, class Alloc >

unordered_map ( InputIt, InputIt, typename /* 아래 참조 */ :: size_type , Alloc )
- > unordered_map < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > ,
std:: hash < /*iter-key-t*/ < InputIt >> ,

std:: equal_to < /*iter-key-t*/ < InputIt >> , Alloc > ;
(3) (C++17부터)
template < class InputIt, class Alloc >

unordered_map ( InputIt, InputIt, Alloc )
- > unordered_map < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > ,
std:: hash < /*iter-key-t*/ < InputIt >> ,

std:: equal_to < /*iter-key-t*/ < InputIt >> , Alloc > ;
(4) (C++17부터)
template < class InputIt, class Hash, class Alloc >

unordered_map ( InputIt, InputIt, typename /* 아래 참조 */ :: size_type , Hash,
Alloc )
- > unordered_map < /*iter-key-t*/ < InputIt > , /*iter-val-t*/ < InputIt > , Hash,

std:: equal_to < /*iter-key-t*/ < InputIt >> , Alloc > ;
(5) (C++17부터)
template < class Key, class T, typename Alloc >

unordered_map ( std:: initializer_list < std:: pair < Key, T >> ,
typename /* 아래 참조 */ :: size_type , Alloc )

- > unordered_map < Key, T, std:: hash < Key > , std:: equal_to < Key > , Alloc > ;
(6) (C++17부터)
template < class Key, class T, typename Alloc >

unordered_map ( std:: initializer_list < std:: pair < Key, T >> , Alloc )

- > unordered_map < Key, T, std:: hash < Key > , std:: equal_to < Key > , Alloc > ;
(7) (C++17부터)
template < class Key, class T, class Hash, class Alloc >

unordered_map ( std:: initializer_list < std:: pair < Key, T >> ,
typename /* 아래 참조 */ :: size_type , Hash, Alloc )

- > unordered_map < Key, T, Hash, std:: equal_to < Key > , Alloc > ;
(8) (C++17부터)
template < ranges:: input_range R,

class Hash = std:: hash < /*range-key-t*/ < R >> ,
class Pred = std:: equal_to < /*range-key-t*/ < R >> ,
class Alloc = std:: allocator < /*range-to-alloc-t*/ < R >> >
unordered_map ( std:: from_range_t , R && ,
typename /* see below */ :: size_type = /* see below */ ,
Hash = Hash ( ) , Pred = Pred ( ) , Alloc = Alloc ( ) )
- > unordered_map < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > ,

Hash, Pred, Alloc > ;
(9) (C++23부터)
template < ranges:: input_range R, class Alloc >

unordered_map ( std:: from_range_t , R && ,
typename /* 아래 참조 */ :: size_type , Alloc )
- > unordered_map < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > ,
std:: hash < /*range-key-t*/ < R >> ,

std:: equal_to < /*range-key-t*/ < R >> , Alloc > ;
(10) (C++23 이후)
template < ranges:: input_range R, class Alloc >

unordered_map ( std:: from_range_t , R && , Alloc )
- > unordered_map < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > ,
std:: hash < /*range-key-t*/ < R >> ,

std:: equal_to < /*range-key-t*/ < R >> , Alloc > ;
(11) (C++23 이후)
template < ranges:: input_range R, class Hash, class Alloc >

unordered_map ( std:: from_range_t , R && , typename /* 아래 참조 */ :: size_type ,
Hash, Alloc )
- > unordered_map < /*range-key-t*/ < R > , /*range-mapped-t*/ < R > , Hash,

std:: equal_to < /*range-key-t*/ < R >> , Alloc > ;
(12) (C++23 이후)
설명 전용 헬퍼 타입 별칭
template < class InputIt >

using /*iter-val-t*/ =

typename std:: iterator_traits < InputIt > :: value_type ;
( 설명 전용* )
template < class InputIt >

using /*iter-key-t*/ =

std:: remove_const_t < std:: tuple_element_t < 0 , /*iter-val-t*/ < InputIt >>> ;
( 설명 전용* )
template < class InputIt >

using /*iter-mapped-t*/ =

std:: tuple_element_t < 1 , /*iter-val-t*/ < InputIt >> ;
( 설명 전용* )
template < class InputIt >

using /*iter-to-alloc-t*/ =
std:: pair < std:: add_const_t < tuple_element_t < 0 , /*iter-val-t*/ < InputIt >>> ,

std:: tuple_element_t < 1 , /*iter-val-t*/ < InputIt >>> ;
( 설명 전용* )
template < ranges:: input_range Range >

using /*range-key-t*/ =

std:: remove_const_t < typename ranges:: range_value_t < Range > :: first_type > ;
(C++23부터)
( 설명 전용* )
template < ranges:: input_range Range >

using /*range-mapped-t*/ =

typename ranges:: range_value_t < Range > :: second_type ;
(C++23부터)
( 설명 전용* )
template < ranges:: input_range Range >

using /*range-to-alloc-t*/ =
std:: pair < std:: add_const_t < typename ranges:: range_value_t < Range > :: first_type > ,

typename ranges:: range_value_t < Range > :: second_type > ;
(C++23부터)
( 설명 전용* )
1-8) 이 deduction guide 는 unordered_map 에 대해 제공되어 반복자 범위(오버로드 (1,3-5) )와 std::initializer_list (오버로드 (2,6-8) )로부터의 추론을 허용합니다.
9-12) 이 추론 가이드들은 unordered_map 에 대해 제공되며, std::from_range_t 태그와 input_range 로부터의 추론을 허용합니다.

이 오버로드들은 다음 조건을 만족할 때에만 오버로드 해결에 참여합니다: InputIt 가 LegacyInputIterator 요구 사항을 충족하고, Alloc 가 Allocator 요구 사항을 충족하며, Hash 와 Pred 모두 Allocator 요구 사항을 충족하지 않으며, Hash 가 정수형이 아닌 경우입니다.

참고: 라이브러리가 특정 타입이 LegacyInputIterator 요구사항을 충족하지 않는다고 판단하는 범위는 명시되지 않았으나, 최소한 정수 타입들은 입력 반복자로 적합하지 않습니다. 마찬가지로, 특정 타입이 Allocator 요구사항을 충족하지 않는다고 판단하는 범위도 명시되지 않았으나, 최소한 멤버 타입 Alloc::value_type 이 존재해야 하며 표현식 std:: declval < Alloc & > ( ) . allocate ( std:: size_t { } ) 가 평가되지 않은 피연산자로 취급될 때 형식이 올바르게 구성되어야 합니다.

이 가이드에서 size_type 매개변수 유형은 추론 가이드에 의해 추론된 유형의 size_type 멤버 유형을 나타냅니다.

참고 사항

기능 테스트 매크로 값 표준 기능
__cpp_lib_containers_ranges 202202L (C++23) Ranges-aware 생성 및 삽입; 오버로드 ( 9-12 )

예제

이 코드 실행 
#include <unordered_map>
int main()
{
    // std::unordered_map m1 = {{"foo", 1}, {"bar", 2}};
        // 오류: 중괄호 초기화 목록에 타입이 없음:
        // {"foo", 1} 또는 {"bar", 2}에서 pair<Key, T>를 추론할 수 없음
    std::unordered_map m1 = {std::pair{"foo", 2}, {"bar", 3}}; // 가이드 #2
    std::unordered_map m2(m1.begin(), m1.end()); // 가이드 #1
}

결함 보고서

다음의 동작 변경 결함 보고서들은 이전에 발표된 C++ 표준에 소급 적용되었습니다.

DR 적용 대상 게시된 동작 올바른 동작
LWG 3025 C++17 initializer-list guides ( 2 ) 및 ( 6-8 ) 가 std:: pair < const Key, T > 를 사용함 std:: pair < Key, T > 를 사용함