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.

_Ax
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