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.

Syntaxe

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>>;

Paramètres

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>>.

Membres

Typedefs publics

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.

Constructeurs publics

Nom	Description
concurrent_unordered_multimap	Surcharge. Construit un multimap non ordonné simultané.

Méthodes publiques

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.

Opérateurs publics

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.

Notes

Pour plus d’informations sur la concurrent_unordered_multimap classe, consultez Conteneurs et objets parallèles.

Hiérarchie d'héritage

_Traits

_Concurrent_hash

concurrent_unordered_multimap

Spécifications

En-tête : concurrent_unordered_map.h

Espace de noms : concurrency

begin

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;

Valeur de retour

Itérateur vers le premier élément du conteneur simultané.

cbegin

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;

Valeur de retour

Itérateur const au premier élément du conteneur simultané.

cend

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;

Valeur de retour

Itérateur const à l’emplacement qui réussit le dernier élément du conteneur simultané.

clear

Efface tous les éléments du conteneur simultané. Cette fonction n’est pas sécurisée par concurrence.

void clear();

concurrent_unordered_multimap

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);

Paramètres

_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.

Notes

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 _Umapnon ordonné simultané.

Le dernier constructeur spécifie un déplacement du multimap _Umapnon ordonné simultané.

count

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;

Paramètres

KVal
Clé à rechercher.

Valeur de retour

Nombre de fois où la clé apparaît dans le conteneur.

empty

Vérifie l'absence d'éléments. Cette méthode est sécurisée pour la concurrence.

bool empty() const;

Valeur de retour

true si le conteneur simultané est vide, false sinon.

Notes

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.

end

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;

Valeur de retour

Itérateur vers l’emplacement qui réussit le dernier élément du conteneur simultané.

equal_range

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;

Paramètres

KVal
Valeur de clé à rechercher.

Valeur de retour

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.

Notes

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.

find

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;

Paramètres

KVal
Valeur de clé à rechercher.

Valeur de retour

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.

get_allocator

Retourne l’objet allocator stocké pour ce conteneur simultané. Cette méthode est sécurisée pour la concurrence.

allocator_type get_allocator() const;

Valeur de retour

Objet allocator stocké pour ce conteneur simultané.

hash_function

Retourne l’objet de fonction de hachage stocké.

hasher hash_function() const;

Valeur de retour

Objet de fonction de hachage stocké.

insert

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);

Paramètres

_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.

Valeur de retour

Itérateur pointant vers l’emplacement d’insertion.

Notes

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.

key_eq

Retourne l’objet de fonction de comparaison d’égalité stockée.

key_equal key_eq() const;

Valeur de retour

Objet de fonction de comparaison d’égalité stockée.

load_factor

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;

Valeur de retour

Facteur de charge pour le conteneur.

max_load_factor

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);

Paramètres

_Newmax

Valeur de retour

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..

max_size

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;

Valeur de retour

Nombre maximal d’éléments pouvant être insérés dans ce conteneur simultané.

Notes

Cette valeur liée supérieure peut réellement être supérieure à ce que le conteneur peut contenir.

opérateur =

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);

Paramètres

_Umap
Objet concurrent_unordered_multimap source.

Valeur de retour

Référence à cet concurrent_unordered_multimap objet.

Notes

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é.

ressasser

Régénère la table de hachage.

void rehash(size_type _Buckets);

Paramètres

_Seaux
Nombre souhaité de compartiments.

Notes

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).

size

Retourne le nombre d’éléments de ce conteneur simultané. Cette méthode est sécurisée pour la concurrence.

size_type size() const;

Valeur de retour

Nombre d’éléments dans le conteneur.

Notes

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.

swap

É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);

Paramètres

_Umap
Objet concurrent_unordered_multimap à échanger.

unsafe_begin

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;

Paramètres

_Seau
Index de compartiment.

Valeur de retour

Itérateur pointant vers le début du compartiment.

unsafe_bucket

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;

Paramètres

KVal
Clé d’élément recherchée.

Valeur de retour

Index de compartiment pour la clé dans ce conteneur.

unsafe_bucket_count

Retourne le nombre actuel de compartiments dans ce conteneur.

size_type unsafe_bucket_count() const;

Valeur de retour

Nombre actuel de compartiments dans ce conteneur.

unsafe_bucket_size

Retourne le nombre d’éléments dans un compartiment spécifique de ce conteneur.

size_type unsafe_bucket_size(size_type _Bucket);

Paramètres

_Seau
Compartiment à rechercher.

Valeur de retour

Nombre actuel de compartiments dans ce conteneur.

unsafe_cbegin

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;

Paramètres

_Seau
Index de compartiment.

Valeur de retour

Itérateur pointant vers le début du compartiment.

unsafe_cend

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;

Paramètres

_Seau
Index de compartiment.

Valeur de retour

Itérateur pointant vers le début du compartiment.

unsafe_end

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;

Paramètres

_Seau
Index de compartiment.

Valeur de retour

Itérateur pointant vers la fin du compartiment.

unsafe_erase

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);

Paramètres

_Où
Position de l’itérateur à effacer.

KVal
Valeur de clé à effacer.

first
last
Itérateurs.

Valeur de retour

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.

Notes

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).

unsafe_max_bucket_count

Retourne le nombre maximal de compartiments dans ce conteneur.

size_type unsafe_max_bucket_count() const;

Valeur de retour

Nombre maximal de compartiments dans ce conteneur.

Voir aussi

accès concurrentiel Namespace
Conteneurs et objets parallèles