concurrent_priority_queue, classe
La classe concurrent_priority_queue est un conteneur qui permet à plusieurs threads d'appeler simultanément des méthodes Push et Pop sur des éléments. Les éléments sont dépilés dans l'ordre de priorité dans lequel la priorité est déterminée par un functor fourni comme argument de modèle.
Syntaxe
template <typename T,
typename _Compare= std::less<T>,
typename _Ax = std::allocator<T>
>,
typename _Ax = std::allocator<T>> class concurrent_priority_queue;
Paramètres
T
Type de données des éléments à stocker dans la file d’attente de priorité.
_Comparer
Type de l’objet de fonction qui peut comparer deux valeurs d’élément en tant que clés de tri pour déterminer leur ordre relatif dans la file d’attente de priorité. Cet argument est facultatif et le prédicat binaire less<T> est la valeur par défaut.
_Hache
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 file d’attente de priorité simultanée. Cet argument est facultatif et sa valeur par défaut est allocator<T>.
Membres
Typedefs publics
| Nom | Description |
|---|---|
allocator_type |
Type qui représente la classe d’allocator pour la file d’attente de priorité simultanée. |
const_reference |
Type qui représente une référence const à un élément du type stocké dans une file d’attente de priorité simultanée. |
reference |
Type qui représente une référence à un élément du type stocké dans une file d’attente de priorité simultanée. |
size_type |
Type qui compte le nombre d’éléments dans une file d’attente de priorité simultanée. |
value_type |
Type qui représente le type de données stocké dans une file d’attente de priorité simultanée. |
Constructeurs publics
| Nom | Description |
|---|---|
| concurrent_priority_queue | Surcharge. Construit une file d’attente de priorité simultanée. |
Méthodes publiques
| Nom | Description |
|---|---|
| clear | Efface tous les éléments de la priorité simultanée. Cette méthode n’est pas sécurisée par concurrence. |
| empty | Teste si la file d’attente de priorité simultanée est vide au moment où cette méthode est appelée. Cette méthode est concurrency-safe. |
| get_allocator | Retourne une copie de l’allocateur utilisé pour construire la file d’attente de priorité simultanée. Cette méthode est concurrency-safe. |
| push | Surcharge. Ajoute un élément à la file d’attente de priorité simultanée. Cette méthode est concurrency-safe. |
| size | Retourne le nombre d’éléments dans la file d’attente de priorité simultanée. Cette méthode est concurrency-safe. |
| swap | Échange le contenu de deux files d’attente de priorité simultanées. Cette méthode n’est pas sécurisée par concurrence. |
| try_pop | Supprime et retourne l’élément de priorité la plus élevée de la file d’attente si la file d’attente n’est pas vide. Cette méthode est concurrency-safe. |
Opérateurs publics
| Nom | Description |
|---|---|
| operator= | Surcharge. Affecte le contenu d’un autre concurrent_priority_queue objet à celui-ci. Cette méthode n’est pas sécurisée par concurrence. |
Notes
Pour plus d’informations sur la concurrent_priority_queue classe, consultez Conteneurs et objets parallèles.
Hiérarchie d'héritage
concurrent_priority_queue
Spécifications
En-tête : concurrent_priority_queue.h
Espace de noms : concurrency
clear
Efface tous les éléments de la priorité simultanée. Cette méthode n’est pas sécurisée par concurrence.
void clear();
Notes
clear n’est pas sécurisé par la concurrence. Vous devez vous assurer qu’aucun autre thread n’appelle des méthodes sur la file d’attente de priorité simultanée lorsque vous appelez cette méthode. clear ne libère pas de mémoire.
concurrent_priority_queue
Construit une file d’attente de priorité simultanée.
explicit concurrent_priority_queue(
const allocator_type& _Al = allocator_type());
explicit concurrent_priority_queue(
size_type _Init_capacity,
const allocator_type& _Al = allocator_type());
template<typename _InputIterator>
concurrent_priority_queue(_InputIterator _Begin,
_InputIterator _End,
const allocator_type& _Al = allocator_type());
concurrent_priority_queue(
const concurrent_priority_queue& _Src);
concurrent_priority_queue(
const concurrent_priority_queue& _Src,
const allocator_type& _Al);
concurrent_priority_queue(
concurrent_priority_queue&& _Src);
concurrent_priority_queue(
concurrent_priority_queue&& _Src,
const allocator_type& _Al);
Paramètres
_InputIterator
Type de l'itérateur d'entrée.
_Al
Classe allocator à utiliser avec cet objet.
_Init_capacity
Capacité initiale de l’objet concurrent_priority_queue .
_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.
_Src
Objet source concurrent_priority_queue à partir duquel copier ou déplacer des éléments.
Notes
Tous les constructeurs stockent un objet _Al d’allocator et initialisent la file d’attente de priorité.
Le premier constructeur spécifie une file d’attente de priorité initiale vide et spécifie éventuellement un allocateur.
Le deuxième constructeur spécifie une file d’attente de priorité avec une capacité _Init_capacity initiale et spécifie éventuellement un allocateur.
Le troisième constructeur spécifie les valeurs fournies par la plage d’itérateur [ _Begin, _End) et spécifie éventuellement un allocateur.
Les quatrième et cinquième constructeurs spécifient une copie de la file d’attente _Srcde priorité.
Les sixième et septième constructeurs spécifient un déplacement de la file d’attente _Srcde priorité.
empty
Teste si la file d’attente de priorité simultanée est vide au moment où cette méthode est appelée. Cette méthode est concurrency-safe.
bool empty() const;
Valeur de retour
true si la file d’attente de priorité était vide au moment où la fonction a été appelée, false sinon.
get_allocator
Retourne une copie de l’allocateur utilisé pour construire la file d’attente de priorité simultanée. Cette méthode est concurrency-safe.
allocator_type get_allocator() const;
Valeur de retour
Copie de l’allocateur utilisé pour construire l’objet concurrent_priority_queue .
opérateur =
Affecte le contenu d’un autre concurrent_priority_queue objet à celui-ci. Cette méthode n’est pas sécurisée par concurrence.
concurrent_priority_queue& operator= (const concurrent_priority_queue& _Src);
concurrent_priority_queue& operator= (concurrent_priority_queue&& _Src);
Paramètres
_Src
Objet concurrent_priority_queue source.
Valeur de retour
Référence à cet concurrent_priority_queue objet.
push
Ajoute un élément à la file d’attente de priorité simultanée. Cette méthode est concurrency-safe.
void push(const value_type& _Elem);
void push(value_type&& _Elem);
Paramètres
_Elem
Élément à ajouter à la file d’attente de priorité simultanée.
size
Retourne le nombre d’éléments dans la file d’attente de priorité simultanée. Cette méthode est concurrency-safe.
size_type size() const;
Valeur de retour
Nombre d’éléments dans cet concurrent_priority_queue objet.
Notes
La taille retournée est garantie d’inclure tous les éléments ajoutés par des appels à la fonction push. Toutefois, il peut ne pas refléter les résultats des opérations simultanées en attente.
swap
Échange le contenu de deux files d’attente de priorité simultanées. Cette méthode n’est pas sécurisée par concurrence.
void swap(concurrent_priority_queue& _Queue);
Paramètres
_Queue
Objet avec lequel échanger le concurrent_priority_queue contenu.
try_pop
Supprime et retourne l’élément de priorité la plus élevée de la file d’attente si la file d’attente n’est pas vide. Cette méthode est concurrency-safe.
bool try_pop(reference _Elem);
Paramètres
_Elem
Référence à une variable qui sera remplie avec l’élément de priorité la plus élevée, si la file d’attente n’est pas vide.
Valeur de retour
true si une valeur a été dépilée, false sinon.
Voir aussi
accès concurrentiel Namespace
Conteneurs et objets parallèles