concurrent_unordered_multimap, classe
La classe concurrent_unordered_multimap
est un conteneur d'accès concurrentiel sécurisé qui contrôle une séquence à longueur variable d'éléments de type std::pair<const K, _Element_type>
. La séquence est représentée d'une manière à permettre les opérations d'ajout d'accès concurrentiel sécurisé, d'accès à un élément, d'accès à un itérateur et de traversée d'itérateur. Ici, la concurrence-safe signifie que les pointeurs ou les itérateurs sont toujours valides. Il ne s’agit pas d’une garantie d’initialisation d’élément ou d’un ordre de traversée particulier.
template <typename K,
typename _Element_type,
typename _Hasher = std::hash<K>,
typename key_equality = std::equal_to<K>,
typename _Allocator_type = std::allocator<std::pair<const K,
_Element_type>>
>,
typename key_equality = std::equal_to<K>,
typename _Allocator_type = std::allocator<std::pair<const K,
_Element_type>>> class concurrent_unordered_multimap : public details::_Concurrent_hash<details::_Concurrent_unordered_map_traits<K,
_Element_type,
details::_Hash_compare<K,
_Hasher,
key_equality>,
_Allocator_type,
true>>;
K
Type de clé.
_Element_type
Type mappé.
_Hasher
Type d’objet de la fonction de hachage. Cet argument est facultatif et sa valeur par défaut est std::hash<K>
.
key_equality
Type d’objet de fonction de comparaison d’égalité. Cet argument est facultatif et sa valeur par défaut est std::equal_to<K>
.
_Allocator_type
Type qui représente l’objet allocator stocké qui encapsule les détails sur l’allocation et la désallocation de la mémoire pour le vecteur simultané. Cet argument est facultatif et sa valeur par défaut est std::allocator<std::pair<K
,_Element_type>>
.
Nom | Description |
---|---|
allocator_type |
Type d'un allocateur pour la gestion du stockage. |
const_iterator |
Type d'un itérateur constant pour la séquence contrôlée. |
const_local_iterator |
Type d’un itérateur de compartiment constant pour la séquence contrôlée. |
const_pointer |
Type d'un pointeur constant vers un élément. |
const_reference |
Type d'une référence constante à un élément. |
difference_type |
Type d'une distance signée entre deux éléments. |
hasher |
Type de la fonction de hachage. |
iterator |
Type d'un itérateur pour la séquence contrôlée. |
key_equal |
Type de la fonction de comparaison. |
key_type |
Type d'une clé de tri. |
local_iterator |
Type d'un itérateur de compartiment pour la séquence contrôlée. |
mapped_type |
Type d'une valeur mappée associée à chaque clé. |
pointer |
Type d'un pointeur vers un élément. |
reference |
Type d'une référence à un élément. |
size_type |
Type d'une distance non signée entre deux éléments. |
value_type |
Type d’un élément. |
Nom | Description |
---|---|
concurrent_unordered_multimap | Surcharge. Construit un multimap non ordonné simultané. |
Nom | Description |
---|---|
hash_function | Retourne l’objet de fonction de hachage stocké. |
insert | Surcharge. Ajoute des éléments à l’objet concurrent_unordered_multimap . |
key_eq | Retourne l’objet de fonction de comparaison d’égalité stockée. |
swap | Échange le contenu de deux concurrent_unordered_multimap objets. Cette méthode n’est pas sécurisée par concurrence. |
unsafe_erase | Surcharge. Supprime les éléments des concurrent_unordered_multimap positions spécifiées. Cette méthode n’est pas sécurisée par concurrence. |
Nom | Description |
---|---|
operator= | Surcharge. Affecte le contenu d’un autre concurrent_unordered_multimap objet à celui-ci. Cette méthode n’est pas sécurisée par concurrence. |
Pour plus d’informations sur la concurrent_unordered_multimap
classe, consultez Conteneurs et objets parallèles.
_Traits
_Concurrent_hash
concurrent_unordered_multimap
En-tête : concurrent_unordered_map.h
Espace de noms : concurrency
Retourne un itérateur pointant vers le premier élément du conteneur simultané. Cette méthode est sécurisée pour la concurrence.
iterator begin();
const_iterator begin() const;
Itérateur vers le premier élément du conteneur simultané.
Retourne un itérateur const pointant vers le premier élément du conteneur simultané. Cette méthode est sécurisée pour la concurrence.
const_iterator cbegin() const;
Itérateur const au premier élément du conteneur simultané.
Retourne un itérateur const pointant vers l’emplacement qui réussit le dernier élément du conteneur simultané. Cette méthode est sécurisée pour la concurrence.
const_iterator cend() const;
Itérateur const à l’emplacement qui réussit le dernier élément du conteneur simultané.
Efface tous les éléments du conteneur simultané. Cette fonction n’est pas sécurisée par concurrence.
void clear();
Construit un multimap non ordonné simultané.
explicit concurrent_unordered_multimap(
size_type _Number_of_buckets = 8,
const hasher& _Hasher = hasher(),
const key_equal& key_equality = key_equal(),
const allocator_type& _Allocator = allocator_type());
concurrent_unordered_multimap(
const allocator_type& _Allocator);
template <typename _Iterator>
concurrent_unordered_multimap(_Iterator _Begin,
_Iterator _End,
size_type _Number_of_buckets = 8,
const hasher& _Hasher = hasher(),
const key_equal& key_equality = key_equal(),
const allocator_type& _Allocator = allocator_type());
concurrent_unordered_multimap(
const concurrent_unordered_multimap& _Umap);
concurrent_unordered_multimap(
const concurrent_unordered_multimap& _Umap,
const allocator_type& _Allocator);
concurrent_unordered_multimap(
concurrent_unordered_multimap&& _Umap);
_Itérateur
Type de l'itérateur d'entrée.
_Number_of_buckets
Nombre initial de compartiments pour ce multimap non ordonné.
_Hasher
Fonction de hachage pour ce multimap non ordonné.
key_equality
Fonction de comparaison d’égalité pour ce multimap non ordonné.
_Allocator
Allocator pour ce multimap non ordonné.
_Commencer
Position du premier élément de la plage d'éléments à copier.
_Fin
Position du premier élément au-delà de la plage d'éléments à copier.
_Umap
Objet source concurrent_unordered_multimap
à partir duquel copier des éléments.
Tous les constructeurs stockent un objet _Allocator
allocator et initialisent le multimap non ordonné.
Le premier constructeur spécifie un multimap initial vide et spécifie explicitement le nombre de compartiments, de fonction de hachage, de fonction d’égalité et de type d’allocateur à utiliser.
Le deuxième constructeur spécifie un allocateur pour le multimap non ordonné.
Le troisième constructeur spécifie les valeurs fournies par la plage d’itérateurs [ _Begin
, _End
).
Les quatrième et cinquième constructeurs spécifient une copie du multimap _Umap
non ordonné simultané.
Le dernier constructeur spécifie un déplacement du multimap _Umap
non ordonné simultané.
Compte le nombre d’éléments correspondant à une clé spécifiée. Cette fonction est sécurisée pour la concurrence.
size_type count(const key_type& KVal) const;
KVal
Clé à rechercher.
Nombre de fois où la clé apparaît dans le conteneur.
Vérifie l'absence d'éléments. Cette méthode est sécurisée pour la concurrence.
bool empty() const;
true
si le conteneur simultané est vide, false
sinon.
En présence d’insertions simultanées, si le conteneur simultané est vide ou non peut changer immédiatement après l’appel de cette fonction, avant que la valeur de retour soit même lue.
Retourne un itérateur pointant vers l’emplacement qui réussit le dernier élément du conteneur simultané. Cette méthode est sécurisée pour la concurrence.
iterator end();
const_iterator end() const;
Itérateur vers l’emplacement qui réussit le dernier élément du conteneur simultané.
Recherche une plage qui correspond à une clé spécifiée. Cette fonction est sécurisée pour la concurrence.
std::pair<iterator,
iterator> equal_range(
const key_type& KVal);
std::pair<const_iterator,
const_iterator> equal_range(
const key_type& KVal) const;
KVal
Valeur de clé à rechercher.
Paire où le premier élément est un itérateur au début et le deuxième élément est un itérateur à la fin de la plage.
Il est possible que les insertions simultanées entraînent l’insertion de clés supplémentaires après l’itérateur de début et avant l’itérateur de fin.
Recherche un élément qui correspond à une clé spécifiée. Cette fonction est sécurisée pour la concurrence.
iterator find(const key_type& KVal);
const_iterator find(const key_type& KVal) const;
KVal
Valeur de clé à rechercher.
Itérateur pointant vers l’emplacement du premier élément qui correspond à la clé fournie ou à l’itérateur end()
s’il n’existe aucun élément de ce type.
Retourne l’objet allocator stocké pour ce conteneur simultané. Cette méthode est sécurisée pour la concurrence.
allocator_type get_allocator() const;
Objet allocator stocké pour ce conteneur simultané.
Retourne l’objet de fonction de hachage stocké.
hasher hash_function() const;
Objet de fonction de hachage stocké.
Ajoute des éléments à l’objet concurrent_unordered_multimap
.
iterator insert(
const value_type& value);
iterator insert(
const_iterator _Where,
const value_type& value);
template<class _Iterator>
void insert(_Iterator first,
_Iterator last);
template<class V>
iterator insert(
V&& value);
template<class V>
typename std::enable_if<!std::is_same<const_iterator,
typename std::remove_reference<V>::type>::value,
iterator>::type insert(
const_iterator _Where,
V&& value);
_Itérateur
Type d’itérateur utilisé pour l’insertion.
V
Type de la valeur insérée dans la carte.
valeur
Valeur à insérer.
_Où
Emplacement de départ à rechercher un point d’insertion.
first
Début de la plage à insérer.
last
Fin de la plage à insérer.
Itérateur pointant vers l’emplacement d’insertion.
La première fonction membre insère l’élément value
dans la séquence contrôlée, puis retourne l’itérateur qui désigne l’élément inséré.
La deuxième fonction membre retourne insert( value
), à l’aide _Where
d’un emplacement de départ dans la séquence contrôlée pour rechercher le point d’insertion.
La troisième fonction membre insère la séquence de valeurs d’élément de la plage [ first
, last
).
Les deux dernières fonctions membres se comportent de la même façon que les deux premières, sauf qu’elles value
sont utilisées pour construire la valeur insérée.
Retourne l’objet de fonction de comparaison d’égalité stockée.
key_equal key_eq() const;
Objet de fonction de comparaison d’égalité stockée.
Calcule et retourne le facteur de charge actuel du conteneur. Le facteur de charge est le nombre d’éléments du conteneur divisé par le nombre de compartiments.
float load_factor() const;
Facteur de charge pour le conteneur.
Obtient ou définit le facteur de charge maximal du conteneur. Le facteur de charge maximal est le plus grand nombre d’éléments que ce qui peut se trouver dans n’importe quel compartiment avant que le conteneur augmente sa table interne.
float max_load_factor() const;
void max_load_factor(float _Newmax);
_Newmax
La première fonction membre retourne le facteur de charge maximale stockée. La deuxième fonction membre ne retourne pas de valeur, mais lève une exception out_of_range si le facteur de charge fourni n’est pas valide..
Retourne la taille maximale du conteneur simultané, déterminée par l’allocateur. Cette méthode est sécurisée pour la concurrence.
size_type max_size() const;
Nombre maximal d’éléments pouvant être insérés dans ce conteneur simultané.
Cette valeur liée supérieure peut réellement être supérieure à ce que le conteneur peut contenir.
Affecte le contenu d’un autre concurrent_unordered_multimap
objet à celui-ci. Cette méthode n’est pas sécurisée par concurrence.
concurrent_unordered_multimap& operator= (const concurrent_unordered_multimap& _Umap);
concurrent_unordered_multimap& operator= (concurrent_unordered_multimap&& _Umap);
_Umap
Objet concurrent_unordered_multimap
source.
Référence à cet concurrent_unordered_multimap
objet.
Après l’effacement d’éléments existants dans un multimap non ordonné simultané, operator=
copie ou déplace le contenu du _Umap
multimap non ordonné simultané.
Régénère la table de hachage.
void rehash(size_type _Buckets);
_Seaux
Nombre souhaité de compartiments.
La fonction membre modifie le nombre de compartiments pour qu’il soit au moins égal à _Buckets
et régénère la table de hachage en fonction des besoins. Le nombre de compartiments doit être une puissance de 2. S’il ne s’agit pas d’une puissance de 2, elle sera arrondie à la plus grande puissance de 2.
Elle lève une exception out_of_range si le nombre de compartiments n’est pas valide (soit 0 ou supérieur au nombre maximal de compartiments).
Retourne le nombre d’éléments de ce conteneur simultané. Cette méthode est sécurisée pour la concurrence.
size_type size() const;
Nombre d’éléments dans le conteneur.
En présence d’insertions simultanées, le nombre d’éléments dans le conteneur simultané peut changer immédiatement après l’appel de cette fonction, avant que la valeur de retour soit même lue.
Échange le contenu de deux concurrent_unordered_multimap
objets. Cette méthode n’est pas sécurisée par concurrence.
void swap(concurrent_unordered_multimap& _Umap);
_Umap
Objet concurrent_unordered_multimap
à échanger.
Retourne un itérateur au premier élément de ce conteneur pour un compartiment spécifique.
local_iterator unsafe_begin(size_type _Bucket);
const_local_iterator unsafe_begin(size_type _Bucket) const;
_Seau
Index de compartiment.
Itérateur pointant vers le début du compartiment.
Retourne l’index de compartiment auquel une clé spécifique est mappée dans ce conteneur.
size_type unsafe_bucket(const key_type& KVal) const;
KVal
Clé d’élément recherchée.
Index de compartiment pour la clé dans ce conteneur.
Retourne le nombre actuel de compartiments dans ce conteneur.
size_type unsafe_bucket_count() const;
Nombre actuel de compartiments dans ce conteneur.
Retourne le nombre d’éléments dans un compartiment spécifique de ce conteneur.
size_type unsafe_bucket_size(size_type _Bucket);
_Seau
Compartiment à rechercher.
Nombre actuel de compartiments dans ce conteneur.
Retourne un itérateur au premier élément de ce conteneur pour un compartiment spécifique.
const_local_iterator unsafe_cbegin(size_type _Bucket) const;
_Seau
Index de compartiment.
Itérateur pointant vers le début du compartiment.
Retourne un itérateur à l’emplacement qui réussit le dernier élément d’un compartiment spécifique.
const_local_iterator unsafe_cend(size_type _Bucket) const;
_Seau
Index de compartiment.
Itérateur pointant vers le début du compartiment.
Retourne un itérateur au dernier élément de ce conteneur pour un compartiment spécifique.
local_iterator unsafe_end(size_type _Bucket);
const_local_iterator unsafe_end(size_type _Bucket) const;
_Seau
Index de compartiment.
Itérateur pointant vers la fin du compartiment.
Supprime les éléments des concurrent_unordered_multimap
positions spécifiées. Cette méthode n’est pas sécurisée par concurrence.
iterator unsafe_erase(
const_iterator _Where);
size_type unsafe_erase(
const key_type& KVal);
iterator unsafe_erase(
const_iterator first,
const_iterator last);
_Où
Position de l’itérateur à effacer.
KVal
Valeur de clé à effacer.
first
last
Itérateurs.
Les deux premières fonctions membres retournent un itérateur qui désigne le premier élément restant au-delà des éléments supprimés, ou concurrent_unordered_multimap::end
() s’il n’existe aucun élément de ce type. La troisième fonction membre retourne le nombre d’éléments qu’elle supprime.
La première fonction membre supprime l’élément de la séquence contrôlée pointée par _Where
. La deuxième fonction membre supprime les éléments de la plage [ _Begin
, _End
).
La troisième fonction membre supprime les éléments de la plage délimitée par concurrent_unordered_multimap::equal_range
(KVal).
Retourne le nombre maximal de compartiments dans ce conteneur.
size_type unsafe_max_bucket_count() const;
Nombre maximal de compartiments dans ce conteneur.
accès concurrentiel Namespace
Conteneurs et objets parallèles