Namespaces
Variants

C++ named requirements: UnorderedAssociativeContainer (since C++11)

From cppreference.net
C++
C++ named requirements

비정렬 연관 컨테이너는 키를 기반으로 객체의 빠른 조회를 제공하는 Container s 입니다. 최악의 경우 복잡도는 선형이지만 대부분의 연산에 대해 평균적으로 훨씬 더 빠릅니다.

비정렬 연관 컨테이너는 Key ; Key 에 대한 해시 함수 역할을 하는 함수 객체 Hash ; 그리고 Key 들 간의 동등성을 평가하는 Pred 로 매개변수화됩니다. std::unordered_map 과 std::unordered_multimap 은 또한 Key 와 연관된 매핑된 타입 T 를 가집니다.

두 개의 Key 가 Pred 에 따라 동일하다면, Hash 는 두 키 모두에 대해 동일한 값을 반환해야 합니다.

Hash::is_transparent 와 Pred::is_transparent 가 모두 존재하고 각각 타입을 명명하는 경우, 멤버 함수 find , contains , count , equal_range , bucket 은 Key 타입 이외의 인수를 허용하며, Hash 가 해당 타입의 값으로 호출 가능하고 Pred 가 std::equal_to<> 와 같은 투명 비교 함수일 것으로 기대합니다.

(C++20부터)

std::unordered_map 와 std::unordered_set 은 주어진 키를 가진 요소를 최대 하나만 포함할 수 있는 반면, std::unordered_multiset 과 std::unordered_multimap 은 동일한 키를 가진 여러 요소를 포함할 수 있습니다 (이러한 요소들은 반복 시 항상 인접해 있어야 합니다).

std::unordered_set 과 std::unordered_multiset 의 경우 값 타입은 키 타입과 동일하며, iterator 와 const_iterator 모두 상수 반복자입니다. std::unordered_map 과 std::unordered_multimap 의 값 타입은 std:: pair < const Key, T > 입니다.

정렬되지 않은 연관 컨테이너의 요소들은 버킷으로 구성되며, 동일한 해시를 가진 키들은 같은 버킷에 위치하게 됩니다. 컨테이너의 크기가 증가함에 따라 버킷의 수는 증가하여 각 버킷당 평균 요소 수를 특정 값 이하로 유지합니다.

재해싱은 반복자를 무효화하고 요소들이 다른 버킷으로 재배열될 수 있지만, 요소에 대한 참조는 무효화하지 않습니다.

비정렬 연관 컨테이너는 AllocatorAwareContainer 요구 사항을 충족합니다. std::unordered_map 과 std::unordered_multimap 의 경우 AllocatorAwareContainer 의 value_type 요구 사항은 key_type 과 mapped_type 에 적용됩니다( value_type 에 적용되지 않음).

목차

요구사항

범례
X 정렬되지 않은 연관 컨테이너 클래스
a X 타입의 값
a2 X 타입과 호환되는 노드를 가진 타입의 값
b X 또는 const X 타입의 값
a_uniq X 타입의 값, X 가 고유 키를 지원할 때
a_eq X 타입의 값으로, X 가 동등 키를 지원하는 경우
a_tran X::key_equal::is_transparent 와 X::hasher::is_transparent 한정자 식별자들이 모두 유효하고 타입 을 나타낼 때, X 타입 또는 const X 타입의 값
i , j value_type 을 참조하는 입력 반복자
[ i , j ) 유효한 범위
rg (C++23부터) R 타입의 값으로 container-compatible-range <value_type> 를 모델링함
p , q2 a 에 대한 유효한 상수 반복자
q , q1 a 에 대한 유효한 역참조 가능한 상수 반복자
r a 에 대한 유효한 역참조 가능 반복자
[ q1 , q2 ) a의 유효한 범위
il std:: initializer_list < value_type > 타입의 값
t X::value_type 타입의 값
k key_type 타입의 값
hf hasher 타입의 값 또는 const hasher
eq key_equal 타입의 값 또는 const key_equal
ke 다음 조건을 만족하는 값:
  • eq ( r1, ke ) == eq ( ke, r1 ) ,
  • hf ( r1 ) == hf ( ke ) 만약 eq ( r1, ke ) 가 true 인 경우, 그리고
  • 만약 eq ( r1, ke ) , eq ( r2, ke ) , 그리고 eq ( r1, r2 ) 중 두 개가 true 이면, 세 개 모두 true 입니다.

여기서 r1 과 r2 는 a_tran 내 요소들의 키입니다.

kx (C++23부터) 다음 조건을 만족하는 값:
  • eq ( r1, kx ) == eq ( kx, r1 ) ,
  • hf ( r1 ) == hf ( kx ) (단, eq ( r1, kx ) 가 true 인 경우),
  • eq ( r1, kx ) , eq ( r2, kx ) , 그리고 eq ( r1, r2 ) 중 임의의 두 조건이 true 이면, 세 조건 모두 true 이어야 함, 그리고
  • kx 가 iterator 또는 const_iterator 로 변환 가능하지 않음,

여기서 r1 과 r2 는 a_tran 내 요소들의 키임

n size_type 타입의 값
z float 타입의 값
nh (C++17부터) X :: node_type 타입의 rvalue

멤버 타입

이름 타입 요구사항 비고
X::key_type Key
X::mapped_type T std::unordered_map 및 std::unordered_multimap 전용
X::value_type Key std::unordered_set 및 std::unordered_multiset 전용. Erasable in X
std:: pair < const Key, T > std::unordered_map 및 std::unordered_multimap 전용. Erasable in X
X::hasher Hash Hash
X::key_equal Pred CopyConstructible ; BinaryPredicate that takes two arguments of type Key and expresses an equivalence relation
X::local_iterator LegacyIterator Category and types are the same as X::iterator 단일 버킷 내에서 순회 가능하지만 버킷 간 순회는 불가능
X::const_local_iterator LegacyIterator Category and types are the same as X::const_iterator
X::node_type (since C++17) A specialization of node-handle class template The public nested types are the same as the corresponding types in X

멤버 함수와 연산자

표현식 결과 사전 조건 효과 반환값 복잡도
X ( n, hf, eq ) 최소 n 개의 버킷을 갖는 빈 컨테이너를 생성하며, hf 를 해시 함수로, eq 를 키 동등성 조건자로 사용합니다 O ( n )
X ( n, hf ) key_equal 는 DefaultConstructible 입니다 최소 n 개의 버킷을 가진 빈 컨테이너를 생성하며, hf 를 해시 함수로, key_equal ( ) 를 키 동등성 조건자로 사용합니다 O ( n )
X ( n ) hasher 와 key_equal 이 DefaultConstructible 인 경우 최소 n 개의 버킷을 가진 빈 컨테이너를 생성하며, hasher ( ) 를 해시 함수로, key_equal ( ) 를 키 동등성 판단 함수로 사용합니다 O ( n )
X a = X ( ) ;
X a ; 		hasher 와 key_equal 이 DefaultConstructible 인 경우 해시 함수로 hasher ( ) 를, 키 동등 조건자로 key_equal ( ) 를 사용하여 지정되지 않은 수의 버킷을 가진 빈 컨테이너를 생성합니다 상수 시간
X ( i, j, n, hf, eq ) value_type 이 EmplaceConstructible 여야 하며 X 에 * i 로부터 생성 가능해야 함 최소 n 개의 버킷을 가진 빈 컨테이너를 생성하며, hf 를 해시 함수로, eq 를 키 동등성 조건자로 사용하고, [ i , j ) 범위의 요소들을 삽입함 평균 경우 O(N) ( N 은 std:: distance ( i, j ) 임), 최악 경우 O(N 2 )
X ( i, j, n, hf ) key_equal 는 DefaultConstructible 여야 합니다. value_type 은 EmplaceConstructible 이며 X 에 * i 로부터 생성 가능해야 합니다. 최소 n 개의 버킷을 가진 빈 컨테이너를 생성하며, hf 를 해시 함수로, key_equal ( ) 를 키 동등성 조건자로 사용하고, [ i , j ) 범위의 요소들을 삽입합니다. 평균 경우 O(N) ( N 은 std:: distance ( i, j ) 임), 최악 경우 O(N 2 )
X ( i, j, n ) hasher 와 key_equal 이 DefaultConstructible 여야 합니다. value_type 이 EmplaceConstructible 여야 하며 * i 로부터 X 에 생성 가능해야 합니다. 최소 n 개의 버킷을 가진 빈 컨테이너를 생성하며, hasher ( ) 를 해시 함수로, key_equal ( ) 를 키 동등성 판단 함수로 사용합니다. 또한 [ i , j ) 범위의 요소들을 컨테이너에 삽입합니다. 평균 경우 O(N) ( N 은 std:: distance ( i, j ) 임), 최악 경우 O(N 2 )
X ( i, j ) hasher 와 key_equal 이 DefaultConstructible 여야 합니다. value_type 이 EmplaceConstructible 여야 하며, * i 로부터 X 에 생성 가능해야 합니다. 지정되지 않은 버킷 수를 가진 빈 컨테이너를 생성하며, hasher ( ) 를 해시 함수로, key_equal ( ) 를 키 동등 조건자로 사용합니다. 또한 [ i , j ) 범위의 요소들을 컨테이너에 삽입합니다. 평균 경우 O(N) ( N 은 std:: distance ( i, j ) 임), 최악 경우 O(N 2 )
X ( std:: from_range ,
rg, n, hf, eq )
(C++23부터) 		value_type 이 EmplaceConstructible 로 X 에 * ranges:: begin ( rg ) 로부터 생성 가능해야 함 최소 n 개의 버킷을 가지는 빈 컨테이너를 생성하고, hf 를 해시 함수로, eq 를 키 동등성 조건자로 사용하며, rg 로부터 요소들을 삽입함 평균 경우 O(N) ( N 은 ranges:: distance ( rg ) 임), 최악 경우 O(N 2 )
X ( std:: from_range ,
rg, n, hf )
(C++23부터) 		key_equal 이 DefaultConstructible 이어야 합니다. value_type 이 EmplaceConstructible 이어야 하며 X 에 * ranges:: begin ( rg ) 로부터 생성 가능해야 합니다. 최소 n 개의 버킷을 가지는 빈 컨테이너를 생성하며, hf 를 해시 함수로, key_equal ( ) 를 키 동등성 조건자로 사용하고, rg 의 요소들을 삽입합니다. 평균 경우 O(N) ( N 은 ranges:: distance ( rg ) 임), 최악 경우 O(N 2 )
X ( std:: from_range ,
rg, n )
(C++23부터) 		hasher 와 key_equal 이 DefaultConstructible 이고, value_type 이 EmplaceConstructible 이며, * ranges:: begin ( rg ) 로부터 X 에 삽입 가능할 때 최소 n 개의 버킷을 가지는 빈 컨테이너를 생성하며, hasher ( ) 를 해시 함수로, key_equal ( ) 를 키 동등성 조건자로 사용하고, rg 의 요소들을 삽입합니다 평균 경우 O(N) ( N 은 ranges:: distance ( rg ) 임), 최악 경우 O(N 2 )
X ( std:: from_range ,
rg )
(C++23부터) 		hasher 와 key_equal 이 DefaultConstructible 이고, value_type 이 EmplaceConstructible 이며 X 에 * ranges:: begin ( rg ) 로부터 생성 가능할 때 지정되지 않은 수의 버킷을 가진 빈 컨테이너를 생성하며, hasher ( ) 를 해시 함수로, key_equal ( ) 를 키 동등성 조건자로 사용하고, rg 의 요소들을 삽입합니다 평균 경우 O(N) ( N 은 ranges:: distance ( rg ) 임), 최악 경우 O(N 2 )
X ( il ) X ( il. begin ( ) , il. end ( ) )
X ( il, n ) X ( il. begin ( ) , il. end ( ) , n )
X ( il, n, hf ) X ( il. begin ( ) , il. end ( ) , n, hf )
X ( il, n, hf, eq ) X ( il. begin ( ) , il. end ( ) , n, hf, eq )
X ( b ) Container ; 해시 함수, 조건자 및 최대 로드 팩터를 복사합니다 평균적인 경우 b. size ( ) 에 선형, 최악의 경우 O(N 2 )
a = b X& Container ; 해시 함수, 조건자 및 최대 로드 팩터를 복사합니다 평균적인 경우 b. size ( ) 에 선형, 최악의 경우 O(N 2 )
a = il X& value_type 이 CopyInsertable 이고 X 에 CopyAssignable 인 경우 범위 [ il. begin ( ) , il. end ( ) ) 를 a 에 할당합니다. a 의 모든 기존 요소들은 할당되거나 파괴됩니다 평균적으로 il. size ( ) 에 선형적이며, 최악의 경우 O(N 2 )
b. hash_function ( ) hasher b 의 해시 함수 상수
b. key_eq ( ) key_equal b 의 키 동등성 조건자 상수
a_uniq. emplace ( args ) std:: pair <
iterator,
bool > 		value_type 이 EmplaceConstructible 요구사항을 만족하며 X 에 args 로부터 생성 가능해야 함 std:: forward < Args > ( args ) ... 로 생성된 value_type 객체 t 를 삽입합니다. 단, 컨테이너에 t 의 키와 동등한 키를 가진 요소가 없을 때만 삽입이 수행됩니다. 반환된 pair의 bool 구성 요소는 삽입이 수행된 경우에만 true 이며, pair의 iterator 구성 요소는 t 의 키와 동등한 키를 가진 요소를 가리킵니다. 평균 경우 O(1) , 최악 경우 O ( a_uniq. size ( ) )
a_eq. emplace ( args ) iterator value_type 이 EmplaceConstructible 요구사항을 만족하며 X 에 args 로부터 생성 가능해야 함 std:: forward < Args > ( args ) ... 로 생성된 value_type 객체 t 를 삽입함 새로 삽입된 요소를 가리키는 반복자 평균 경우 O(1) , 최악의 경우 O ( a_eq. size ( ) )
a. emplace_hint ( p, args ) iterator value_type 이 EmplaceConstructible 로 X 에 args 로부터 생성 가능해야 함 a. emplace (
std:: forward < Args > ( args ) ... ) 		새로 삽입된 요소와 키가 동등한 요소를 가리키는 반복자. const_iterator p 는 검색을 시작해야 할 위치를 가리키는 힌트입니다. 구현체는 이 힌트를 무시할 수 있음 평균 경우 O(1) , 최악 경우 O ( a. size ( ) )
a_uniq. insert ( t ) std:: pair <
iterator,
bool > 		만약 t 가 non-const rvalue인 경우, value_type 은 MoveInsertable 이어야 하며, 그렇지 않은 경우 value_type 은 CopyInsertable 이어야 합니다. t 의 키와 동등한 키를 가진 요소가 컨테이너에 없는 경우에만 t 를 삽입합니다. 반환된 pair의 bool 구성 요소는 삽입이 발생했는지 여부를 나타내며, iterator 구성 요소는 t 의 키와 동등한 키를 가진 요소를 가리킵니다. 평균 경우 O(1) , 최악 경우 O ( a_uniq. size ( ) )
a_eq. insert ( t ) iterator 만약 t 가 non-const rvalue인 경우, value_type 은 MoveInsertable 을 X 에 대해 만족해야 합니다; 그렇지 않은 경우, value_type 은 CopyInsertable 을 X 에 대해 만족해야 합니다 t 를 삽입합니다 새로 삽입된 요소를 가리키는 반복자 평균 경우 O(1) , 최악 경우 O ( a_eq. size ( ) )
a. insert ( p, t ) iterator 만약 t 가 non-const rvalue라면, value_type 은 MoveInsertable 을 X 에 대해 만족해야 합니다; 그렇지 않으면, value_type 은 CopyInsertable 을 X 에 대해 만족해야 합니다 a. insert ( t ) 와 동일합니다. 반복자 p 는 검색을 시작할 위치를 가리키는 힌트입니다. 구현체는 이 힌트를 무시할 수 있습니다 t 의 키와 동등한 키를 가진 요소를 가리키는 반복자 평균 경우 O(1) , 최악 경우 O ( a. size ( ) )
a. insert ( i, j ) void value_type 는 EmplaceConstructible 로서 X 에 * i 로부터 생성 가능해야 함. i 와 j 는 a 의 반복자가 아님 a. insert ( t ) 를
[ i , j ) 범위의 각 요소에 대해 수행 		평균 경우 O(N) , 여기서 N 은 std:: distance ( i, j ) , 최악 경우 O ( N· ( a. size ( ) + 1 ) )
a. insert_range ( rg )
(C++23부터) 		void value_type 이 EmplaceConstructible 로 X 에 * ranges:: begin ( rg ) 로부터 생성 가능해야 함. rg 와 a 는 겹치지 않아야 함 a. insert ( t ) 를 rg 의 각 요소 t 에 대해 수행 평균 경우 O(N) , 여기서 N 은 ranges:: distance ( rg ) , 최악 경우 O ( N· ( a. size ( ) + 1 ) )
a. insert ( il ) a. insert ( il. begin ( ) , il. end ( ) )
a_uniq. insert ( nh )
(C++17부터) 		insert_return_type nh 가 비어 있거나

a_uniq. get_allocator ( )
==
nh. get_allocator ( ) 가 true

만약 nh 가 비어 있으면, 아무런 효과가 없습니다. 그렇지 않으면, 컨테이너에 nh. key ( ) 와 동등한 키를 가진 요소가 없는 경우에만 nh 가 소유한 요소를 삽입합니다. 보장: 만약 nh 가 비어 있으면, inserted 는 false , position 은 end ( ) 이고, node 는 비어 있습니다. 그렇지 않고 삽입이 발생한 경우, inserted 는 true , position 은 삽입된 요소를 가리키고, node 는 비어 있습니다; 삽입이 실패한 경우, inserted 는 false , node 는 nh 의 이전 값을 가지며, position 은 nh. key ( ) 와 동등한 키를 가진 요소를 가리킵니다. 평균 경우 O(1) , 최악 경우 O ( a_uniq. size ( ) )
a_eq. insert ( nh )
(C++17부터) 		iterator nh 가 비어 있거나

a_eq. get_allocator ( )
==
nh. get_allocator ( ) 가 true

만약 nh 가 비어 있다면, 아무 효과도 없으며 a_eq. end ( ) 를 반환합니다. 그렇지 않으면, nh 가 소유한 요소를 삽입하고 새로 삽입된 요소를 가리키는 반복자를 반환합니다. 다음을 보장합니다: nh 가 비어 있게 됨 평균 경우 O(1) , 최악의 경우 O ( a_eq. size ( ) )
a. insert ( q, nh )
(C++17부터) 		iterator nh 가 비어 있거나

a. get_allocator ( )
==
nh. get_allocator ( ) 가 true

만약 nh 가 비어 있다면, 아무 효과도 없으며 a. end ( ) 를 반환합니다. 그렇지 않으면, 고유 키를 가진 컨테이너에서는 nh. key ( ) 와 동등한 키를 가진 요소가 없는 경우에만 nh 가 소유한 요소를 삽입합니다; 동등 키를 가진 컨테이너에서는 항상 nh 가 소유한 요소를 삽입합니다. 반복자 q 는 검색을 시작해야 할 위치를 가리키는 힌트입니다. 구현체는 이 힌트를 무시할 수 있습니다. 보장사항: 삽입이 성공하면 nh 는 비어 있고, 삽입이 실패하면 변경되지 않습니다. nh. key ( ) 와 동등한 키를 가진 요소를 가리키는 반복자 평균 경우 O(1) , 최악 경우 O ( a. size ( ) )
a. extract ( k )
(C++17부터) 		node_type 키가 k 와 동일한 요소를 컨테이너에서 제거합니다 요소를 찾은 경우 해당 요소를 소유하는 node_type , 그렇지 않으면 빈 node_type 평균 경우 O(1) , 최악 경우 O ( a. size ( ) )
a_tran. extract ( kx )
(C++23부터) 		node_type 키가 kx 와 동등한 요소를 컨테이너에서 제거합니다 요소를 찾은 경우 해당 요소를 소유하는 node_type , 그렇지 않으면 빈 node_type 평균 경우 O(1) , 최악 경우 O ( a_tran. size ( ) )
a. extract ( q )
(C++17부터) 		node_type q 가 가리키는 요소를 제거합니다 해당 요소를 소유하는 node_type 평균 경우 O(1) , 최악 경우 O ( a. size ( ) )
a. merge ( a2 )
(C++17부터) 		void a. get_allocator ( )
==
a2. get_allocator ( ) 		a2 의 각 요소를 추출하여 a 의 해시 함수와 키 동등 조건자를 사용하여 a 에 삽입하려고 시도합니다. 고유 키를 가진 컨테이너에서, a 에 a2 의 요소 키와 동등한 키를 가진 요소가 있으면 해당 요소는 a2 에서 추출되지 않습니다. 보장사항: a2 의 전송된 요소에 대한 포인터와 참조는 동일한 요소를 참조하지만 a 의 멤버로서 참조합니다. 전송된 요소를 참조하는 반복자와 a 를 참조하는 모든 반복자는 무효화되지만, a2 에 남아있는 요소에 대한 반복자는 유효하게 유지됩니다 평균 경우 O(N) , 여기서 N 은 a2. size ( ) , 최악 경우 O ( N· ( a. size ( ) + 1 ) )
a. erase ( k ) size_type 키가 k 와 동등한 모든 요소를 삭제 삭제된 요소의 수 평균 경우 O ( a. count ( k ) ), 최악의 경우 O ( a. size ( ) )
a_tran. erase ( kx )
(C++23 이후) 		size_type 키가 kx 와 동등한 모든 요소를 삭제합니다 삭제된 요소의 수 평균적인 경우 O ( a_tran. count ( kx ) ), 최악의 경우 O ( a_tran. size ( ) )
a. erase ( q ) iterator q가 가리키는 요소를 삭제합니다 삭제 전 q 바로 다음의 반복자 평균 경우 O(1) , 최악 경우 O ( a. size ( ) )
a. erase ( r )
(C++17부터) 		iterator r이 가리키는 요소를 삭제합니다 삭제 전 r 바로 다음의 반복자 평균 경우 O(1) , 최악 경우 O ( a. size ( ) )
a. erase ( q1, q2 ) iterator 범위 내의 모든 요소를 삭제합니다
[ q1 , q2 ) 		삭제 전 삭제된 요소들 바로 다음의 반복자 평균적으로 std:: distance ( q1, q2 ) 에 선형, 최악의 경우 O ( a. size ( ) )
a. clear ( ) void 컨테이너의 모든 요소를 삭제합니다. 다음을 보장합니다: a. empty ( ) 가 true 가 됩니다 a. size ( ) 에 대해 선형 시간
b. find ( k ) iterator ; const_iterator 상수 버전 b 키 k 와 동등한 요소를 가리키는 반복자, 또는 해당 요소가 존재하지 않을 경우 b. end ( ) 를 반환 평균 경우 O(1) , 최악 경우 O ( b. size ( ) )
a_tran. find ( ke )
(C++17 이후) ? 		iterator ; const_iterator 상수 객체용 a_tran ke 와 동등한 키를 가진 원소를 가리키는 반복자. 해당하는 원소가 없을 경우 a_tran. end ( ) 를 반환 평균 경우 O(1) , 최악 경우 O ( a_tran. size ( ) )
b. count ( k ) size_type 키가 k 와 동등한 요소의 개수 평균 경우 O ( b. count ( k ) ), 최악의 경우 O ( b. size ( ) )
a_tran. count ( ke )
(C++17부터) ? 		size_type 키가 ke 와 동등한 요소의 개수 평균 경우 O ( a_tran. count ( ke ) ), 최악의 경우 O ( a_tran. size ( ) )
b. contains ( k )
(C++20부터) ? 		b. find ( k ) ! = b. end ( )
a_tran. contains ( ke )
(C++20부터) ? 		a_tran. find ( ke ) ! = a_tran. end ( )
b. equal_range ( k ) std:: pair <
iterator,
iterator > ;

std:: pair <
const_iterator,
const_iterator > 상수 b 용

키가 k 와 동등한 모든 요소를 포함하는 범위. 해당하는 요소가 없으면

std:: make_pair (
b. end ( ) , b. end ( ) ) 를 반환함

평균 경우 O ( b. count ( k ) ), 최악의 경우 O ( b. size ( ) )
a_tran. equal_range ( ke )
(C++20부터) ? 		std:: pair <
iterator,
iterator > ;

std:: pair <
const_iterator,
const_iterator > 상수 객체에 대해 a_tran

ke 키와 동등한 모든 요소를 포함하는 범위. 해당 요소가 존재하지 않으면

std:: make_pair (
a_tran. end ( ) ,
a_tran. end ( ) ) 를 반환

평균 경우 O ( a_tran. count ( ke ) ), 최악 경우 O ( a_tran. size ( ) )
b. bucket_count ( ) size_type b 가 포함하는 버킷의 수 상수
b. max_bucket_count ( ) size_type b가 가질 수 있는 버킷 수의 상한 상수
b. bucket ( k ) size_type b. bucket_count ( ) > 0 키 k 와 동등한 키를 가진 요소가 존재한다면, 해당 요소가 위치하게 될 버킷의 인덱스입니다. 반환 값은 [ ​ 0 ​ , b. bucket_count ( ) ) 범위 내에 있습니다. 상수 시간
a_tran. bucket ( ke ) size_type a_tran.
bucket_count ( ) > 0 		ke 와 동등한 키를 가진 요소가 존재한다면, 해당 요소가 위치하게 될 버킷의 인덱스입니다. 반환 값은 [ ​ 0 ​ , a_tran. bucket_count ( ) ) 범위 내에 있어야 합니다. 상수 시간
b. bucket_size ( n ) size_type n 이 다음 범위 내에 있음 [ ​ 0 ​ , b. bucket_count ( ) ) n 번째 버킷에 있는 요소의 수 O ( b. bucket_size ( n ) )
b. begin ( n ) local_iterator ; const_local_iterator 상수 버전 b n 이 [ ​ 0 ​ , b. bucket_count ( ) ) 범위 내에 있음 버킷의 첫 번째 요소를 참조하는 반복자. 버킷이 비어 있는 경우 b. begin ( n ) == b. end ( n ) 상수 시간
b. end ( n ) local_iterator ; const_local_iterator 상수 버전 n 이 [ ​ 0 ​ , b. bucket_count ( ) ) 범위 내에 있을 때 버킷의 끝(past-the-end) 값을 나타내는 반복자 상수 시간
b. cbegin ( n ) const_local_iterator n 이 [ ​ 0 ​ , b. bucket_count ( ) ) 범위 내에 있음 버킷의 첫 번째 요소를 참조하는 반복자. 버킷이 비어 있는 경우 b. cbegin ( n ) == b. cend ( n ) 상수 시간
b. cend ( n ) const_local_iterator n 이 [ ​ 0 ​ , b. bucket_count ( ) ) 범위 내에 있을 때 버킷의 끝을 지난 값을 가리키는 반복자 상수
b. load_factor ( ) float 버킷당 평균 요소 수 상수 시간
b. max_load_factor ( ) float 컨테이너가 부하 계수가 이 값보다 작거나 같도록 유지하려고 시도하는 양수입니다. 컨테이너는 부하 계수가 이 값보다 낮게 유지되도록 필요한 경우 자동으로 버킷 수를 증가시킵니다 상수
a. max_load_factor ( z ) void z 는 양수입니다. z 를 힌트로 사용하여 컨테이너의 최대 로드 팩터를 변경할 수 있습니다 상수 시간
a. rehash ( n ) void 보장 조건:

a. bucket_count ( ) >=
a. size ( ) / a. max_load_factor ( ) 그리고 a. bucket_count ( ) >= n

평균적인 경우 a. size ( ) 에 선형적, 최악의 경우 O(N 2 )
a. reserve ( n ) a. rehash ( std:: ceil (
n / a. max_load_factor ( ) ) )
이 섹션은 불완전합니다
이유: 멤버 함수 관련 요구사항.

표준 라이브러리

다음 표준 라이브러리 컨테이너들은 UnorderedAssociativeContainer 요구 사항을 충족합니다:

(C++11)
키로 해시된 고유 키들의 컬렉션
(클래스 템플릿)
(C++11)
키로 해시된 키들의 컬렉션
(클래스 템플릿)
(C++11)
키로 해시된 키-값 쌍들의 컬렉션, 키는 고유함
(클래스 템플릿)
(C++11)
키로 해시된 키-값 쌍들의 컬렉션
(클래스 템플릿)

결함 보고서

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

DR 적용 대상 게시된 동작 올바른 동작
LWG 2156 C++11 재해시 후 로드 팩터는 최대 로드 팩터보다
엄격하게 낮아야만 했음 		동일한 값도 허용됨