C++ named requirements: UnorderedAssociativeContainer (since C++11)
Les conteneurs associatifs non ordonnés sont des Container s qui fournissent une recherche rapide d'objets basée sur des clés. La complexité dans le pire cas est linéaire mais en moyenne beaucoup plus rapide pour la plupart des opérations.
Les conteneurs associatifs non ordonnés sont paramétrés par
Key
;
Hash
, un objet fonction
Hash
qui agit comme fonction de hachage sur
Key
; et
Pred
, un
BinaryPredicate
évaluant l'équivalence entre les
Key
s.
std::unordered_map
et
std::unordered_multimap
possèdent également un type mappé
T
associé à la
Key
.
Si deux
Key
sont égaux selon
Pred
,
Hash
doit renvoyer la même valeur pour les deux clés.
|
Si les deux
|
(depuis C++20) |
std::unordered_map et std::unordered_set peuvent contenir au plus un élément avec une clé donnée, std::unordered_multiset et std::unordered_multimap peuvent quant à eux contenir plusieurs éléments avec la même clé (qui doivent toujours être adjacents lors des itérations).
Pour
std::unordered_set
et
std::unordered_multiset
le type de valeur est identique au type de clé et à la fois
iterator
et
const_iterator
sont des itérateurs constants.
Pour
std::unordered_map
et
std::unordered_multimap
le type de valeur est
std::
pair
<
const
Key, T
>
.
Les éléments dans un conteneur associatif non ordonné sont organisés en compartiments, les clés avec le même hachage se retrouveront dans le même compartiment. Le nombre de compartiments est augmenté lorsque la taille du conteneur augmente pour maintenir le nombre moyen d'éléments dans chaque compartiment sous une certaine valeur.
Le rehachage invalide les itérateurs et peut entraîner la réorganisation des éléments dans différents compartiments, mais il n'invalide pas les références vers les éléments.
Les conteneurs associatifs non ordonnés satisfont aux exigences de
AllocatorAwareContainer
.
Pour
std::unordered_map
et
std::unordered_multimap
les exigences de
value_type
dans
AllocatorAwareContainer
s'appliquent à
key_type
et
mapped_type
(et non à
value_type
).
Table des matières |
Exigences
Légende |
|
X
|
Une classe de conteneur associatif non ordonné |
| a |
Une valeur de type
X
|
| a2 |
Une valeur d'un type avec
des nœuds compatibles avec le type
X
|
| b |
Une valeur de type
X
ou
const X
|
| a_uniq |
Une valeur de type
X
lorsque
X
prend en charge les clés uniques
|
| a_eq |
Une valeur de type
X
lorsque
X
prend en charge les clés équivalentes
|
| a_tran |
Une valeur de type
X
ou
const
X
lorsque les identifiants qualifiés
X::key_equal::is_transparent
et
X::hasher::is_transparent
sont tous deux valides et désignent des
types
|
| i , j |
Itérateurs d'entrée qui se réfèrent à
value_type
|
[
i
,
j
)
|
Une plage valide |
| rg (depuis C++23) |
Une valeur d'un type
R
qui modélise
container-compatible-range
<value_type>
|
| p , q2 | Itérateurs constants valides vers a |
| q , q1 | Itérateurs constants valides et déréférençables vers a |
| r | Un itérateur déréférençable valide vers a |
[
q1
,
q2
)
|
Une plage valide dans a |
| il | Une valeur de type std:: initializer_list < value_type > |
| t |
Une valeur de type
X::value_type
|
| k |
Une valeur de type
key_type
|
| hf |
Une valeur de type
hasher
ou
const
hasher
|
| eq |
Une valeur de type
key_equal
ou
const
key_equal
|
| ke |
Une valeur telle que
où r1 et r2 sont des clés d'éléments dans a_tran |
| kx (depuis C++23) |
Une valeur telle que
où r1 et r2 sont des clés d'éléments dans a_tran |
| n |
Une valeur de type
size_type
|
| z | Une valeur de type float |
| nh (depuis C++17) | Une valeur rvalue de type X :: node_type |
Types membres
| Nom | Type | Exigences | Notes |
|---|---|---|---|
X::key_type
|
Key
|
||
X::mapped_type
|
T
|
std::unordered_map et std::unordered_multimap uniquement | |
X::value_type
|
Key
|
std::unordered_set
et
std::unordered_multiset
uniquement.
Effaçable
dans
X
|
|
| std:: pair < const Key, T > |
std::unordered_map
et
std::unordered_multimap
uniquement.
Effaçable
dans
X
|
||
X::hasher
|
Hash
|
Hash | |
X::key_equal
|
Pred
|
CopyConstructible
;
BinaryPredicate
qui prend deux arguments de type
Key
et exprime une relation d'équivalence
|
|
X::local_iterator
|
LegacyIterator |
Catégorie et types identiques à
X::iterator
|
Peut être utilisé pour itérer à travers un seul compartiment, mais pas entre les compartiments |
X::const_local_iterator
|
LegacyIterator |
Catégorie et types identiques à
X::const_iterator
|
|
X::node_type
(depuis C++17)
|
Une spécialisation du modèle de classe node-handle |
Les types imbriqués publics sont identiques aux types correspondants dans
X
|
Fonctions membres et opérateurs
| Expression | Résultat | Préconditions | Effets | Retours | Complexité |
|---|---|---|---|---|---|
| X ( n, hf, eq ) | Construit un conteneur vide avec au moins n compartiments, utilisant hf comme fonction de hachage et eq comme prédicat d'égalité des clés | O ( n ) | |||
| X ( n, hf ) |
key_equal
est
DefaultConstructible
|
Construit un conteneur vide avec au moins n compartiments, utilisant hf comme fonction de hachage et key_equal ( ) comme prédicat d'égalité des clés | O ( n ) | ||
| X ( n ) |
hasher
et
key_equal
sont
DefaultConstructible
|
Construit un conteneur vide avec au moins n compartiments, utilisant hasher ( ) comme fonction de hachage et key_equal ( ) comme prédicat d'égalité des clés | O ( n ) | ||
|
X a
=
X
(
)
;
X a ; |
hasher
et
key_equal
sont
DefaultConstructible
|
Construit un conteneur vide avec un nombre non spécifié de compartiments, utilisant hasher ( ) comme fonction de hachage et key_equal ( ) comme prédicat d'égalité des clés | Constant | ||
| X ( i, j, n, hf, eq ) |
value_type
est
EmplaceConstructible
dans
X
à partir de
*
i
|
Construit un conteneur vide avec au moins
n
compartiments, en utilisant
hf
comme fonction de hachage et
eq
comme prédicat d'égalité des clés, et insère les éléments de
[
i
,
j
)
dans celui-ci
|
Cas moyen O(N) ( N est std:: distance ( i, j ) ), cas le pire O(N 2 ) | ||
| X ( i, j, n, hf ) |
key_equal
est
DefaultConstructible
.
value_type
est
EmplaceConstructible
dans
X
à partir de
*
i
|
Construit un conteneur vide avec au moins
n
compartiments, utilisant
hf
comme fonction de hachage et
key_equal
(
)
comme prédicat d'égalité des clés, et insère les éléments de
[
i
,
j
)
dedans
|
Cas moyen O(N) ( N est std:: distance ( i, j ) ), cas le pire O(N 2 ) | ||
| X ( i, j, n ) |
hasher
et
key_equal
sont
DefaultConstructible
.
value_type
est
EmplaceConstructible
dans
X
à partir de
*
i
|
Construit un conteneur vide avec au moins
n
compartiments, en utilisant
hasher
(
)
comme fonction de hachage et
key_equal
(
)
comme prédicat d'égalité de clé, et insère les éléments de
[
i
,
j
)
dans celui-ci
|
Cas moyen O(N) ( N est std:: distance ( i, j ) ), cas le plus défavorable O(N 2 ) | ||
| X ( i, j ) |
hasher
et
key_equal
sont
DefaultConstructible
.
value_type
est
EmplaceConstructible
dans
X
à partir de
*
i
|
Construit un conteneur vide avec un nombre non spécifié de compartiments, en utilisant
hasher
(
)
comme fonction de hachage et
key_equal
(
)
comme prédicat d'égalité des clés, et insère les éléments de
[
i
,
j
)
dans celui-ci
|
Cas moyen O(N) ( N est std:: distance ( i, j ) ), cas le plus défavorable O(N 2 ) | ||
|
X
(
std::
from_range
,
rg, n, hf, eq ) (depuis C++23) |
value_type
est
EmplaceConstructible
dans
X
à partir de
*
ranges::
begin
(
rg
)
|
Construit un conteneur vide avec au moins n compartiments, en utilisant hf comme fonction de hachage et eq comme prédicat d'égalité des clés, et insère les éléments de rg dans celui-ci | Cas moyen O(N) ( N est ranges:: distance ( rg ) ), cas le plus défavorable O(N 2 ) | ||
|
X
(
std::
from_range
,
rg, n, hf ) (depuis C++23) |
key_equal
est
DefaultConstructible
.
value_type
est
EmplaceConstructible
dans
X
à partir de
*
ranges::
begin
(
rg
)
|
Construit un conteneur vide avec au moins n compartiments, utilisant hf comme fonction de hachage et key_equal ( ) comme prédicat d'égalité des clés, et insère les éléments de rg dans celui-ci | Cas moyen O(N) ( N est ranges:: distance ( rg ) ), cas le plus défavorable O(N 2 ) | ||
|
X
(
std::
from_range
,
rg, n ) (depuis C++23) |
hasher
et
key_equal
sont
DefaultConstructible
.
value_type
est
EmplaceConstructible
dans
X
à partir de
*
ranges::
begin
(
rg
)
|
Construit un conteneur vide avec au moins n compartiments, en utilisant hasher ( ) comme fonction de hachage et key_equal ( ) comme prédicat d'égalité des clés, et insère les éléments de rg dans celui-ci | Cas moyen O(N) ( N est ranges:: distance ( rg ) ), cas le pire O(N 2 ) | ||
|
X
(
std::
from_range
,
rg ) (depuis C++23) |
hasher
et
key_equal
sont
DefaultConstructible
.
value_type
est
EmplaceConstructible
dans
X
à partir de
*
ranges::
begin
(
rg
)
|
Construit un conteneur vide avec un nombre non spécifié de compartiments, utilisant hasher ( ) comme fonction de hachage et key_equal ( ) comme prédicat d'égalité des clés, et insère les éléments de rg dans celui-ci | Cas moyen O(N) ( N est ranges:: distance ( rg ) ), cas le pire 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 ; Copie la fonction de hachage, le prédicat et le facteur de charge maximum | Cas moyen linéaire en b. size ( ) , cas le pire O(N 2 ) | |||
| a = b |
X&
|
Container ; copie la fonction de hachage, le prédicat et le facteur de charge maximum | Cas moyen linéaire en b. size ( ) , cas le pire O(N 2 ) | ||
| a = il |
X&
|
value_type
est
CopyInsertable
dans
X
et
CopyAssignable
|
Assigne la plage
[
il.
begin
(
)
,
il.
end
(
)
)
dans
a
. Tous les éléments existants de
a
sont soit assignés soit détruits
|
Cas moyen linéaire en il. size ( ) , cas pire O(N 2 ) | |
| b. hash_function ( ) |
hasher
|
b fonction de hachage de b | Constante | ||
| b. key_eq ( ) |
key_equal
|
b prédicat d'égalité de clé de b | Constante | ||
| a_uniq. emplace ( args ) |
std::
pair
<
iterator, bool > |
value_type
est
EmplaceConstructible
dans
X
à partir de
args
|
Insère un objet
value_type
t
construit avec
std::
forward
<
Args
>
(
args
)
...
si et seulement s'il n'existe aucun élément dans le conteneur avec une clé équivalente à celle de
t
|
La composante bool de la paire retournée est true si et seulement si l'insertion a lieu, et la composante itérateur de la paire pointe vers l'élément avec une clé équivalente à celle de t | Cas moyen O(1) , cas le plus défavorable O ( a_uniq. size ( ) ) |
| a_eq. emplace ( args ) |
iterator
|
value_type
est
EmplaceConstructible
dans
X
à partir de
args
|
Insère un objet
value_type
t
construit avec
std::
forward
<
Args
>
(
args
)
...
|
Un itérateur pointant vers l'élément nouvellement inséré | Cas moyen O(1) , cas pire O ( a_eq. size ( ) ) |
| a. emplace_hint ( p, args ) |
iterator
|
value_type
est
EmplaceConstructible
dans
X
à partir de
args
|
a.
emplace
(
std:: forward < Args > ( args ) ... ) |
Un itérateur pointant vers l'élément avec la clé équivalente à l'élément nouvellement inséré. Le
const_iterator
p
est un indice pointant vers l'endroit où la recherche devrait commencer. Les implémentations sont autorisées à ignorer l'indice
|
Cas moyen O(1) , cas le pire O ( a. size ( ) ) |
| a_uniq. insert ( t ) |
std::
pair
<
iterator, bool > |
Si
t
est une rvalue non constante,
value_type
doit être
MoveInsertable
dans
X
; sinon,
value_type
doit être
CopyInsertable
dans
X
|
Insère t si et seulement s'il n'existe aucun élément dans le conteneur avec une clé équivalente à celle de t |
La composante
bool
de la paire retournée indique si l'insertion a eu lieu, et la composante
iterator
pointe vers l'élément avec une clé équivalente à celle de
t
|
Cas moyen O(1) , cas le pire O ( a_uniq. size ( ) ) |
| a_eq. insert ( t ) |
iterator
|
Si
t
est une rvalue non constante,
value_type
doit être
MoveInsertable
dans
X
; sinon,
value_type
doit être
CopyInsertable
dans
X
|
Insère t | Un itérateur pointant vers l'élément nouvellement inséré | Cas moyen O(1) , cas le pire O ( a_eq. size ( ) ) |
| a. insert ( p, t ) |
iterator
|
Si
t
est une rvalue non constante,
value_type
doit être
MoveInsertable
dans
X
; sinon,
value_type
doit être
CopyInsertable
dans
X
|
a. insert ( t ) . L'itérateur p est un indicateur pointant vers l'endroit où la recherche doit commencer. Les implémentations sont autorisées à ignorer l'indicateur | Un itérateur pointant vers l'élément avec la clé équivalente à celle de t | Cas moyen O(1) , cas le pire O ( a. size ( ) ) |
| a. insert ( i, j ) | void |
value_type
est
EmplaceConstructible
dans
X
à partir de
*
i
. Ni
i
ni
j
ne sont des itérateurs vers
a
|
a.
insert
(
t
)
pour chaque élément dans
[
i
,
j
)
|
Cas moyen O(N) , où N est std:: distance ( i, j ) , cas le pire O ( N· ( a. size ( ) + 1 ) ) | |
|
a.
insert_range
(
rg
)
(depuis C++23) |
void |
value_type
est
EmplaceConstructible
dans
X
à partir de
*
ranges::
begin
(
rg
)
.
rg
et
a
ne se chevauchent pas
|
a. insert ( t ) pour chaque élément t dans rg | Cas moyen O(N) , où N est ranges:: distance ( rg ) , cas pire O ( N· ( a. size ( ) + 1 ) ) | |
| a. insert ( il ) | a. insert ( il. begin ( ) , il. end ( ) ) | ||||
|
a_uniq.
insert
(
nh
)
(depuis C++17) |
insert_return_type
|
nh
est vide ou
a_uniq.
get_allocator
(
)
|
Si nh est vide, n'a aucun effet. Sinon, insère l'élément possédé par nh si et seulement s'il n'y a pas d'élément dans le conteneur avec une clé équivalente à nh. key ( ) . Garantit : Si nh est vide, inserted est false , position est end ( ) , et node est vide. Sinon si l'insertion a eu lieu, inserted est true , position pointe vers l'élément inséré, et node est vide ; si l'insertion a échoué, inserted est false , node a la valeur précédente de nh , et position pointe vers un élément avec une clé équivalente à nh. key ( ) | Cas moyen O(1) , cas le pire O ( a_uniq. size ( ) ) | |
|
a_eq.
insert
(
nh
)
(depuis C++17) |
iterator
|
nh
est vide ou
a_eq.
get_allocator
(
)
|
Si nh est vide, n'a aucun effet et retourne a_eq. end ( ) . Sinon, insère l'élément possédé par nh et retourne un itérateur pointant vers l'élément nouvellement inséré. Garantit : nh est vide | Cas moyen O(1) , cas pire O ( a_eq. size ( ) ) | |
|
a.
insert
(
q, nh
)
(depuis C++17) |
iterator
|
nh
est vide ou
a.
get_allocator
(
)
|
Si nh est vide, n'a aucun effet et retourne a. end ( ) . Sinon, insère l'élément possédé par nh si et seulement s'il n'y a pas d'élément avec une clé équivalente à nh. key ( ) dans les conteneurs avec des clés uniques ; insère toujours l'élément possédé par nh dans les conteneurs avec des clés équivalentes. L'itérateur q est un indice indiquant où la recherche devrait commencer. Les implémentations sont autorisées à ignorer l'indice. Garantit : nh est vide si l'insertion réussit, inchangé si l'insertion échoue | Un itérateur pointant vers l'élément avec une clé équivalente à nh. key ( ) | Cas moyen O(1) , cas pire O ( a. size ( ) ) |
|
a.
extract
(
k
)
(depuis C++17) |
node_type
|
Supprime un élément du conteneur avec une clé équivalente à k |
Un
node_type
possédant l'élément s'il est trouvé, sinon un
node_type
vide
|
Cas moyen O(1) , cas le pire O ( a. size ( ) ) | |
|
a_tran.
extract
(
kx
)
(depuis C++23) |
node_type
|
Supprime un élément du conteneur avec une clé équivalente à kx |
Un
node_type
possédant l'élément s'il est trouvé, sinon un
node_type
vide
|
Cas moyen O(1) , cas le pire O ( a_tran. size ( ) ) | |
|
a.
extract
(
q
)
(depuis C++17) |
node_type
|
Supprime l'élément pointé par q |
Un
node_type
possédant cet élément
|
Cas moyen O(1) , cas le plus défavorable O ( a. size ( ) ) | |
|
a.
merge
(
a2
)
(depuis C++17) |
void |
a.
get_allocator
(
)
== a2. get_allocator ( ) |
Tente d'extraire chaque élément dans a2 et de l'insérer dans a en utilisant la fonction de hachage et le prédicat d'égalité des clés de a . Dans les conteneurs avec des clés uniques, s'il existe un élément dans a avec une clé équivalente à la clé d'un élément de a2 , alors cet élément n'est pas extrait de a2 . Garantit : Les pointeurs et références vers les éléments transférés de a2 se réfèrent à ces mêmes éléments mais en tant que membres de a . Les itérateurs se référant aux éléments transférés et tous les itérateurs se référant à a seront invalidés, mais les itérateurs vers les éléments restant dans a2 resteront valides | Cas moyen O(N) , où N est a2. size ( ) , cas pire O ( N· ( a. size ( ) + 1 ) ) | |
| a. erase ( k ) |
size_type
|
Supprime tous les éléments dont la clé est équivalente à k | Le nombre d'éléments supprimés | Cas moyen O ( a. count ( k ) ), cas le plus défavorable O ( a. size ( ) ) | |
|
a_tran.
erase
(
kx
)
(depuis C++23) |
size_type
|
Supprime tous les éléments dont la clé est équivalente à kx | Le nombre d'éléments supprimés | Cas moyen O ( a_tran. count ( kx ) ), cas le plus défavorable O ( a_tran. size ( ) ) | |
| a. erase ( q ) |
iterator
|
Supprime l'élément pointé par q | L'itérateur immédiatement suivant q avant la suppression | Cas moyen O(1) , cas le plus défavorable O ( a. size ( ) ) | |
|
a.
erase
(
r
)
(depuis C++17) |
iterator
|
Supprime l'élément pointé par r | L'itérateur immédiatement suivant r avant la suppression | Cas moyen O(1) , cas le plus défavorable O ( a. size ( ) ) | |
| a. erase ( q1, q2 ) |
iterator
|
Supprime tous les éléments dans l'intervalle
[
q1
,
q2
)
|
L'itérateur suivant immédiatement les éléments effacés avant l'effacement | Complexité moyenne linéaire en std:: distance ( q1, q2 ) , pire cas O ( a. size ( ) ) | |
| a. clear ( ) | void | Efface tous les éléments du conteneur. Garantit que : a. empty ( ) est true | Linéaire en fonction de a. size ( ) | ||
| b. find ( k ) |
iterator
;
const_iterator
pour constante
b
|
Un itérateur pointant vers un élément avec une clé équivalente à k , ou b. end ( ) si aucun élément de ce type n'existe | Cas moyen O(1) , cas le plus défavorable O ( b. size ( ) ) | ||
|
a_tran.
find
(
ke
)
(depuis C++17) ? |
iterator
;
const_iterator
pour constante
a_tran
|
Un itérateur pointant vers un élément avec une clé équivalente à ke , ou a_tran. end ( ) si aucun tel élément n'existe | Cas moyen O(1) , cas le pire O ( a_tran. size ( ) ) | ||
| b. count ( k ) |
size_type
|
Le nombre d'éléments dont la clé est équivalente à k | Cas moyen O ( b. count ( k ) ), cas le plus défavorable O ( b. size ( ) ) | ||
|
a_tran.
count
(
ke
)
(depuis C++17) ? |
size_type
|
Le nombre d'éléments avec une clé équivalente à ke | Cas moyen O ( a_tran. count ( ke ) ), cas le plus défavorable O ( a_tran. size ( ) ) | ||
|
b.
contains
(
k
)
(depuis C++20) ? |
b. find ( k ) ! = b. end ( ) | ||||
|
a_tran.
contains
(
ke
)
(depuis C++20) ? |
a_tran. find ( ke ) ! = a_tran. end ( ) | ||||
| b. equal_range ( k ) |
std::
pair
<
iterator, iterator > ;
std::
pair
<
|
Une plage contenant tous les éléments avec des clés équivalentes à
k
. Retourne
std::
make_pair
(
|
Cas moyen O ( b. count ( k ) ), cas le pire O ( b. size ( ) ) | ||
|
a_tran.
equal_range
(
ke
)
(depuis C++20) ? |
std::
pair
<
iterator, iterator > ;
std::
pair
<
|
Une plage contenant tous les éléments avec des clés équivalentes à
ke
. Retourne
std::
make_pair
(
|
Cas moyen O ( a_tran. count ( ke ) ), cas le pire O ( a_tran. size ( ) ) | ||
| b. bucket_count ( ) |
size_type
|
Le nombre de compartiments que b contient | Constant | ||
| b. max_bucket_count ( ) |
size_type
|
Une limite supérieure sur le nombre de buckets que b peut jamais contenir | Constant | ||
| b. bucket ( k ) |
size_type
|
b. bucket_count ( ) > 0 |
L'indice du compartiment dans lequel les éléments avec des clés équivalentes à
k
seraient trouvés, si de tels éléments existaient. La valeur de retour est dans
[
0
,
b.
bucket_count
(
)
)
|
Constant | |
| a_tran. bucket ( ke ) |
size_type
|
a_tran.
bucket_count ( ) > 0 |
L'indice du compartiment dans lequel les éléments avec des clés équivalentes à
ke
seraient trouvés, si de tels éléments existaient. La valeur de retour doit être dans l'intervalle
[
0
,
a_tran.
bucket_count
(
)
)
|
Constant | |
| b. bucket_size ( n ) |
size_type
|
n
est dans
[
0
,
b.
bucket_count
(
)
)
|
Le nombre d'éléments dans le n ème compartiment | O ( b. bucket_size ( n ) ) | |
| b. begin ( n ) |
local_iterator
;
const_local_iterator
pour constant
b
|
n
est dans
[
0
,
b.
bucket_count
(
)
)
|
Un itérateur faisant référence au premier élément du compartiment. Si le compartiment est vide, alors b. begin ( n ) == b. end ( n ) | Constant | |
| b. end ( n ) |
local_iterator
;
const_local_iterator
pour constant
b
|
n
est dans
[
0
,
b.
bucket_count
(
)
)
|
Un itérateur qui représente la valeur après-la-fin pour le compartiment | Constant | |
| b. cbegin ( n ) |
const_local_iterator
|
n
est dans
[
0
,
b.
bucket_count
(
)
)
|
Un itérateur faisant référence au premier élément du compartiment. Si le compartiment est vide, alors b. cbegin ( n ) == b. cend ( n ) | Constant | |
| b. cend ( n ) |
const_local_iterator
|
n
est dans
[
0
,
b.
bucket_count
(
)
)
|
Un itérateur qui représente la valeur après-la-fin pour le compartiment | Constant | |
| b. load_factor ( ) | float | Le nombre moyen d'éléments par compartiment | Constant | ||
| b. max_load_factor ( ) | float | Un nombre positif que le conteneur tente de maintenir comme facteur de charge maximal. Le conteneur augmente automatiquement le nombre de compartiments si nécessaire pour maintenir le facteur de charge en dessous de cette valeur | Constant | ||
| a. max_load_factor ( z ) | void | z est positif. Peut modifier le facteur de charge maximum du conteneur, en utilisant z comme indication | Constant | ||
| a. rehash ( n ) | void |
Garantit :
a.
bucket_count
(
)
>=
|
Cas moyen linéaire en a. size ( ) , cas pire O(N 2 ) | ||
| a. reserve ( n ) |
a.
rehash
(
std::
ceil
(
n / a. max_load_factor ( ) ) ) |
|
Cette section est incomplète
Raison : Exigences concernant les fonctions membres. |
Bibliothèque standard
Les conteneurs standards suivants satisfont aux exigences UnorderedAssociativeContainer :
|
(C++11)
|
collection de clés uniques, hachée par clés
(modèle de classe) |
|
(C++11)
|
collection de clés, hachée par clés
(modèle de classe) |
|
(C++11)
|
collection de paires clé-valeur, hachée par clés, clés uniques
(modèle de classe) |
|
(C++11)
|
collection de paires clé-valeur, hachée par clés
(modèle de classe) |
Rapports de défauts
Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.
| DR | Applicable à | Comportement publié | Comportement corrigé |
|---|---|---|---|
| LWG 2156 | C++11 |
le facteur de charge après rehashing ne pouvait être
que strictement inférieur au facteur de charge maximum |
autorisé à être égal |