concurrent_unordered_map, classe

La classe concurrent_unordered_map 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_map : public details::_Concurrent_hash<details::_Concurrent_unordered_map_traits<K,
    _Element_type,
details::_Hash_compare<K,
    _Hasher,
key_equality>,
    _Allocator_type,
false>>;

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 des détails sur l’allocation et la désallocation de la mémoire pour la carte non ordonnée simultanée. 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_map	Surcharge. Construit une carte non ordonnée simultanée.

Méthodes publiques

Nom	Description
at	Surcharge. Recherche un élément dans une concurrent_unordered_map valeur de clé spécifiée. Cette méthode est concurrency-safe.
hash_function	Obtient l'objet de fonction de hachage stocké.
insert	Surcharge. Ajoute des éléments à l’objet concurrent_unordered_map .
key_eq	Obtient l’objet de fonction de comparaison d’égalité stockée.
swap	Échange le contenu de deux concurrent_unordered_map objets. Cette méthode n’est pas sécurisée par concurrence.
unsafe_erase	Surcharge. Supprime les éléments des concurrent_unordered_map positions spécifiées. Cette méthode n’est pas sécurisée par concurrence.

Opérateurs publics

Nom	Description
operator[]	Surcharge. Recherche ou insère un élément avec la clé spécifiée. Cette méthode est concurrency-safe.
operator=	Surcharge. Affecte le contenu d’un autre concurrent_unordered_map objet à celui-ci. Cette méthode n’est pas sécurisée par concurrence.

Notes

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

Hiérarchie d'héritage

_Traits

_Concurrent_hash

concurrent_unordered_map

Spécifications

En-tête : concurrent_unordered_map.h

Espace de noms : concurrency

at

Recherche un élément dans une concurrent_unordered_map valeur de clé spécifiée. Cette méthode est concurrency-safe.

mapped_type& at(const key_type& KVal);

const mapped_type& at(const key_type& KVal) const;

Paramètres

KVal
Valeur de clé à rechercher.

Valeur de retour

Référence à la valeur de données de l'élément trouvé.

Notes

Si la valeur de clé d’argument est introuvable, la fonction lève un objet de classe out_of_range.

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_map

Construit une carte non ordonnée simultanée.

explicit concurrent_unordered_map(
    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_map(
    const allocator_type& _Allocator);

template <typename _Iterator>
concurrent_unordered_map(_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_map(
    const concurrent_unordered_map& _Umap);

concurrent_unordered_map(
    const concurrent_unordered_map& _Umap,
    const allocator_type& _Allocator);

concurrent_unordered_map(
    concurrent_unordered_map&& _Umap);

Paramètres

_Itérateur
Type de l'itérateur d'entrée.

_Number_of_buckets
Nombre initial de compartiments pour cette carte non ordonnée.

_Hasher
Fonction de hachage pour cette carte non triée.

key_equality
Fonction de comparaison d’égalité pour cette carte non ordonnée.

_Allocator
Allocator pour cette carte non ordonnée.

_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_map à partir duquel copier ou déplacer des éléments.

Notes

Tous les constructeurs stockent un objet _Allocator allocator et initialisent la carte non ordonnée.

Le premier constructeur spécifie une carte initiale 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 la carte non ordonnée.

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 de la carte _Umapnon ordonnée simultanée.

Le dernier constructeur spécifie un déplacement de la carte _Umapnon ordonnée simultanée.

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

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

std::pair<iterator,
    bool> 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>
std::pair<iterator,
    bool> 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.

value
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

Paire qui contient un itérateur et une valeur booléenne. Pour plus d’informations, consultez la section Notes.

Notes

La première fonction membre détermine si un élément X existe dans la séquence dont la clé a un ordre équivalent à celui de value. Si ce n’est pas le cas, il crée un élément X et l’initialise avec value. La fonction détermine ensuite l’itérateur where qui désigne X. Si une insertion s’est produite, la fonction retourne std::pair(where, true). Sinon, std::pair(where, false)est retourné.

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

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

operator[]

Recherche ou insère un élément avec la clé spécifiée. Cette méthode est concurrency-safe.

mapped_type& operator[](const key_type& kval);

mapped_type& operator[](key_type&& kval);

Paramètres

KVal
Valeur de clé à

rechercher ou insérer.

Valeur de retour

Référence à la valeur de données de l’élément trouvé ou inséré.

Notes

Si la valeur de clé d’argument est introuvable, elle est insérée avec la valeur par défaut du type de données.

operator[]peut être utilisé pour insérer des éléments dans une carte à l’aide m[key] = DataValue;de , où DataValue est la valeur de l’élément mapped_type avec une valeur de clé de key.m

Lorsque vous utilisez operator[] pour insérer des éléments, la référence retournée n'indique pas si l'insertion va modifier un élément existant ou en créer un nouveau. Les fonctions find membres et l’insertion peuvent être utilisées pour déterminer si un élément avec une clé spécifiée est déjà présent avant une insertion.

opérateur =

Affecte le contenu d’un autre concurrent_unordered_map objet à celui-ci. Cette méthode n’est pas sécurisée par concurrence.

concurrent_unordered_map& operator= (const concurrent_unordered_map& _Umap);

concurrent_unordered_map& operator= (concurrent_unordered_map&& _Umap);

Paramètres

_Umap
Objet concurrent_unordered_map source.

Valeur de retour

Référence à cet concurrent_unordered_map objet.

Notes

Après l’effacement des éléments existants un vecteur simultané, operator= copie ou déplace le contenu du _Umap vecteur 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_map objets. Cette méthode n’est pas sécurisée par concurrence.

void swap(concurrent_unordered_map& _Umap);

Paramètres

_Umap
Objet concurrent_unordered_map à é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_map positions spécifiées. Cette méthode n’est pas sécurisée par concurrence.

iterator unsafe_erase(
    const_iterator _Where);

iterator unsafe_erase(
    const_iterator _Begin,
    const_iterator _End);

size_type unsafe_erase(
    const key_type& KVal);

Paramètres

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

_Commencer
Position du premier élément dans la plage d’éléments à effacer.

_Fin
Position du premier élément au-delà de la plage d’éléments à effacer.

KVal
Valeur de clé à effacer.

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_map::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_map::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