C++ named requirements: UnorderedAssociativeContainer (since C++11)
順序なし連想コンテナは、キーに基づいたオブジェクトの高速検索を提供する Container s です。 最悪の場合の計算量は線形ですが、ほとんどの操作では平均的にはるかに高速です。
順序なし連想コンテナは、
Key
;
Key
に対するハッシュ関数として機能する関数オブジェクト
Hash
; および
Key
間の等価性を評価する二項述語
Pred
によってパラメータ化されます。
std::unordered_map
および
std::unordered_multimap
は、
Key
に関連付けられたマップ型
T
も持ちます。
2つの
Key
が
Pred
によって等しいと判定される場合、
Hash
は両方のキーに対して同じ値を返さなければなりません。
|
|
(C++20以降) |
std::unordered_map と std::unordered_set は同じキーを持つ要素を最大1つしか保持できないのに対し、 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
と互換性のあるノードを持つ型の値
互換性のあるノードを持つ型
X
|
| b |
X
型または
const X
型の値
|
| a_uniq |
X
型の値（
X
がユニークキーをサポートする場合）
|
| a_eq |
X
型の値（
X
が等価キーをサポートする場合）
|
| a_tran |
X
型または
const
X
型の値（修飾識別子
X::key_equal::is_transparent
および
X::hasher::is_transparent
が両方とも有効であり、
型
を表す場合）
|
| 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 |
以下の条件を満たす値：
ここで r1 と r2 は a_tran 内の要素のキー |
| kx (C++23以降) |
以下の条件を満たす値
ここで r1 と r2 は a_tran 内の要素のキーである |
| n |
size_type
型の値
|
| z | float 型の値 |
| nh (C++17以降) | X :: node_type 型の右辺値 |
メンバー型
| 名前 | 型 | 要件 | 備考 |
|---|---|---|---|
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
であること
X
|
|
| std:: pair < const Key, T > |
std::unordered_map
および
std::unordered_multimap
のみ。
Erasable
であること
X
|
||
X::hasher
|
Hash
|
Hash | |
X::key_equal
|
Pred
|
CopyConstructible
;
BinaryPredicate
であり、
Key
型の2つの引数を取り、同値関係を表すこと
|
|
X::local_iterator
|
LegacyIterator |
カテゴリと型は
X::iterator
と同じ
|
単一のバケット内を反復処理するために使用できるが、バケット間の反復処理はできない |
X::const_local_iterator
|
LegacyIterator |
カテゴリと型は
X::const_iterator
と同じ
|
|
X::node_type
(C++17以降)
|
node-handle クラステンプレートの特殊化 |
公開ネスト型は
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
であり、
X
に
*
i
から構築可能である
|
少なくとも
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
であり、
X
に
*
i
から構築可能である
|
未指定のバケット数で空のコンテナを構築し、
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
であり、
X
に
*
ranges::
begin
(
rg
)
から構築可能である
|
少なくとも 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
|
value_type
オブジェクト
t
を
std::
forward
<
Args
>
(
args
)
...
で構築し、コンテナ内に
t
のキーと等価なキーを持つ要素が存在しない場合にのみ挿入する
|
返されるpairの bool コンポーネントは、挿入が行われた場合にのみ true となり、イテレータコンポーネントは 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
が非const右辺値の場合、
value_type
は
MoveInsertable
でなければならない。それ以外の場合、
value_type
は
CopyInsertable
でなければならない。
|
t のキーと等価なキーを持つ要素がコンテナ内に存在しない場合にのみ t を挿入する |
返されるpairの
bool
コンポーネントは挿入が行われたかどうかを示し、
iterator
コンポーネントは
t
のキーと等価なキーを持つ要素を指す
|
平均ケース O(1) 、最悪ケース O ( a_uniq. size ( ) ) |
| a_eq. insert ( t ) |
iterator
|
t
が非const右辺値の場合、
value_type
は
MoveInsertable
でなければならない。それ以外の場合、
value_type
は
CopyInsertable
でなければならない。
|
t を挿入する | 新しく挿入された要素を指すイテレータ | 平均ケース O(1) 、最悪ケース O ( a_eq. size ( ) ) |
| a. insert ( p, t ) |
iterator
|
t
が非const右辺値の場合、
value_type
は
MoveInsertable
でなければならない。それ以外の場合、
value_type
は
CopyInsertable
でなければならない
|
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 が空の場合、何も行わない。それ以外の場合、 nh が所有する要素を、コンテナ内に nh. key ( ) と等価なキーを持つ要素が存在しない場合にのみ挿入する。保証事項: 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 が空の場合、効果はなく a_eq. end ( ) を返す。それ以外の場合、 nh が所有する要素を挿入し、新しく挿入された要素を指すイテレータを返す。以下のことを保証する： nh は空になる | 平均ケース O(1) 、最悪ケース O ( a_eq. size ( ) ) | |
|
a.
insert
(
q, nh
)
(C++17以降) |
iterator
|
nh
が空であるか、
a.
get_allocator
(
)
|
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
<
|
キー
k
と等価なすべての要素を含む範囲。該当する要素が存在しない場合は
std::
make_pair
(
|
平均ケース O ( b. count ( k ) )、最悪ケース O ( b. size ( ) ) | ||
|
a_tran.
equal_range
(
ke
)
(C++20以降) ? |
std::
pair
<
iterator, iterator > ;
std::
pair
<
|
ke
と等価なキーを持つ全ての要素を含む範囲。該当する要素が存在しない場合は
std::
make_pair
(
|
平均ケース 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
定数用
|
n
が
[
0
,
b.
bucket_count
(
)
)
の範囲内にあること
|
バケット内の最初の要素を指すイテレータ。バケットが空の場合、 b. begin ( n ) == b. end ( n ) | 定数時間 | |
| b. end ( n ) |
local_iterator
;
const_local_iterator
定数用
b
|
n
は
[
0
,
b.
bucket_count
(
)
)
の範囲内
|
バケットの終端値を示すイテレータ | 定数時間 | |
| 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 ( ) に対して線形時間、最悪ケースでは 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 |
再ハッシュ後の負荷係数は最大負荷係数より
厳密に低い場合のみ可能 |
等しいことも許可 |