concurrent_unordered_set, classe

La concurrent_unordered_set classe est un conteneur concurrency-safe qui contrôle une séquence de longueur variable d’éléments de type K. La séquence est représentée de manière à permettre l’ajout concurrentiel sécurisé, l’accès aux éléments, l’accès à l’itérateur et les opérations de traversée de l’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 _Hasher = std::hash<K>,
    typename key_equality = std::equal_to<K>,
    typename _Allocator_type = std::allocator<K>
>,
    typename key_equality = std::equal_to<K>,
    typename _Allocator_type = std::allocator<K>> class concurrent_unordered_set : public details::_Concurrent_hash<details::_Concurrent_unordered_set_traits<K,
    details::_Hash_compare<K,
_Hasher,
    key_equality>,
_Allocator_type,
    false>>;

Paramètres

K
Type de clé.

_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 jeu non ordonné simultané. Cet argument est facultatif et sa valeur par défaut est std::allocator<K>.

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.
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_set	Surcharge. Construit un ensemble 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_set .
key_eq	Retourne l’objet de fonction de comparaison d’égalité stockée.
swap	Échange le contenu de deux concurrent_unordered_set objets. Cette méthode n’est pas sécurisée par concurrence.
unsafe_erase	Surcharge. Supprime les éléments des concurrent_unordered_set 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_set objet à celui-ci. Cette méthode n’est pas sécurisée par concurrence.

Notes

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

Hiérarchie d'héritage

_Traits

_Concurrent_hash

concurrent_unordered_set

Spécifications

En-tête : concurrent_unordered_set.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_set

Construit un ensemble non ordonné simultané.

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

template <typename _Iterator>
concurrent_unordered_set(_Iterator first,
    _Iterator last,
    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_set(
    const concurrent_unordered_set& _Uset);

concurrent_unordered_set(
    const concurrent_unordered_set& _Uset,
    const allocator_type& _Allocator);

concurrent_unordered_set(
    concurrent_unordered_set&& _Uset);

Paramètres

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

_Number_of_buckets
Nombre initial de compartiments pour cet ensemble non ordonné.

_Hasher
Fonction de hachage pour cet ensemble non ordonné.

key_equality
Fonction de comparaison d’égalité pour cet ensemble non ordonné.

_Allocator
Allocateur pour cet ensemble non ordonné.

first
last
_Uset
Objet source concurrent_unordered_set à partir duquel copier ou déplacer des éléments.

Notes

Tous les constructeurs stockent un objet _Allocator allocator et initialisent l’ensemble non ordonné.

Le premier constructeur spécifie un jeu 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 jeu 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 jeu _Usetnon ordonné simultané.

Le dernier constructeur spécifie un déplacement du jeu _Usetnon 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_set .

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

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

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_set objet à celui-ci. Cette méthode n’est pas sécurisée par concurrence.

concurrent_unordered_set& operator= (const concurrent_unordered_set& _Uset);

concurrent_unordered_set& operator= (concurrent_unordered_set&& _Uset);

Paramètres

_Uset
Objet concurrent_unordered_set source.

Valeur de retour

Référence à cet concurrent_unordered_set objet.

Notes

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

void swap(concurrent_unordered_set& _Uset);

Paramètres

_Uset
Objet concurrent_unordered_set à é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_set 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 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 pointé 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 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