priority_queue (STL/CLR)

Article
10/12/2023

La classe de modèle décrit un objet qui contrôle une séquence triée de longueur variable d’éléments ayant un accès limité. Vous utilisez l’adaptateur priority_queue de conteneur pour gérer un conteneur sous-jacent en tant que file d’attente de priorité.

Dans la description ci-dessous, GValue est identique à Value , sauf si ce dernier est un type ref, auquel cas il s’agit Value^. De même, GContainer est identique à Container , sauf si ce dernier est un type ref, auquel cas il s’agit Container^.

Syntaxe

template<typename Value,
    typename Container>
    ref class priority_queue
        System::ICloneable,
        Microsoft::VisualC::StlClr::IPriorityQueue<GValue, GContainer>
    { ..... };

Paramètres

Valeur
Type d'un élément dans la séquence contrôlée.

Conteneur
Type du conteneur sous-jacent.

Spécifications

Header :<cliext/queue>

Espace de noms : cliext

Déclarations

Définition de type	Description
priority_queue::const_reference (STL/CLR)	Type d'une référence constante à un élément.
priority_queue::container_type (STL/CLR)	Type du conteneur sous-jacent.
priority_queue::difference_type (STL/CLR)	Type d'une distance signée entre deux éléments.
priority_queue::generic_container (STL/CLR)	Type de l’interface générique pour l’adaptateur de conteneur.
priority_queue::generic_value (STL/CLR)	Type d’un élément pour l’interface générique de l’adaptateur de conteneur.
priority_queue::reference (STL/CLR)	Type d'une référence à un élément.
priority_queue::size_type (STL/CLR)	Type d'une distance signée entre deux éléments.
priority_queue::value_compare (STL/CLR)	Délégué de classement pour deux éléments.
priority_queue::value_type (STL/CLR)	Type d’un élément.

Fonction membre	Description
priority_queue::assign (STL/CLR)	Remplace tous les éléments.
priority_queue::empty (STL/CLR)	Vérifie l'absence d'éléments.
priority_queue::get_container (STL/CLR)	Accède au conteneur sous-jacent.
priority_queue::pop (STL/CLR)	Supprime l’élément de priorité le plus haut.
priority_queue::priority_queue (STL/CLR)	Construit un objet conteneur.
priority_queue::push (STL/CLR)	Ajoute un nouvel élément.
priority_queue::size (STL/CLR)	Compte le nombre d'éléments.
priority_queue::top (STL/CLR)	Accède à l’élément de priorité la plus élevée.
priority_queue::to_array (STL/CLR)	Copie la séquence contrôlée dans un nouveau tableau.
priority_queue::value_comp (STL/CLR)	Copie le délégué de classement pour deux éléments.

Propriété	Description
priority_queue::top_item (STL/CLR)	Accède à l’élément de priorité la plus élevée.

Opérateur	Description
priority_queue::operator= (STL/CLR)	Remplace la séquence contrôlée.

Interfaces

Interface	Description
ICloneable	Dupliquer un objet.
Valeur IPriorityQueue<, conteneur>	Conservez l’adaptateur de conteneur générique.

Notes

L’objet alloue et libère le stockage pour la séquence qu’il contrôle via un conteneur sous-jacent, de type Container, qui stocke Value les éléments et augmente à la demande. Elle conserve la séquence triée en tant que tas, avec l’élément de priorité la plus élevée (l’élément supérieur) facilement accessible et amovible. L’objet restreint l’accès à l’envoi de nouveaux éléments et à l’apparition uniquement de l’élément de priorité la plus élevée, implémentant une file d’attente de priorité.

L’objet commande la séquence qu’il contrôle en appelant un objet délégué stocké de type priority_queue ::value_compare (STL/CLR). Vous pouvez spécifier l’objet délégué stocké lorsque vous construisez le priority_queue ; si vous ne spécifiez aucun objet délégué, la valeur par défaut est la comparaison operator<(value_type, value_type). Vous accédez à cet objet stocké en appelant la fonction membre priority_queue ::value_comp (STL/CLR).()

Un tel objet délégué doit imposer un ordre faible strict aux valeurs de type priority_queue ::value_type (STL/CLR). Cela signifie que, pour deux clés X et Y:

value_comp()(X, Y) retourne le même résultat booléen sur chaque appel.

Si value_comp()(X, Y) c’est vrai, il value_comp()(Y, X) doit être faux.

Si value_comp()(X, Y) c’est vrai, on X dit d’être ordonné avant Y.

Si !value_comp()(X, Y) && !value_comp()(Y, X) c’est vrai, alors X et Y sont dits avoir un ordre équivalent.

Pour tout élément X qui précède Y dans la séquence contrôlée, key_comp()(Y, X) a la valeur false. (Pour l’objet délégué par défaut, les clés ne diminuent jamais en valeur.)

L’élément de priorité la plus élevée est donc l’un des éléments qui ne sont pas classés avant tout autre élément.

Étant donné que le conteneur sous-jacent conserve les éléments classés en tant que tas :

Le conteneur doit prendre en charge les itérateurs d’accès aléatoire.

Les éléments avec ordre équivalent peuvent être dépilés dans un ordre différent de celui qu’ils ont été poussés. (L’ordre n’est pas stable.)

Ainsi, les candidats pour le conteneur sous-jacent incluent la file d’attente (STL/CLR) et le vecteur (STL/CLR).

Membres

priority_queue::assign (STL/CLR)

Remplace tous les éléments.

Syntaxe

void assign(priority_queue<Value, Container>% right);

Paramètres

right
Adaptateur de conteneur à insérer.

Notes

La fonction membre affecte right.get_container() au conteneur sous-jacent. Vous l’utilisez pour modifier l’intégralité du contenu de la file d’attente.

Exemple

// cliext_priority_queue_assign.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign a repetition of values
    Mypriority_queue c2;
    c2.assign(c1);
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c a b
c a b

priority_queue::const_reference (STL/CLR)

Type d'une référence constante à un élément.

Syntaxe

typedef value_type% const_reference;

Notes

Le type décrit une référence constante à un élément.

Exemple

// cliext_priority_queue_const_reference.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display reversed contents " c b a"
    for (; !c1.empty(); c1.pop())
        {   // get a const reference to an element
        Mypriority_queue::const_reference cref = c1.top();
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

c b a

priority_queue::container_type (STL/CLR)

Type du conteneur sous-jacent.

Syntaxe

typedef Container value_type;

Notes

Le type est un synonyme du paramètre de modèle Container.

Exemple

// cliext_priority_queue_container_type.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display contents " a b c" using container_type
    Mypriority_queue::container_type wc1 = c1.get_container();
    for each (wchar_t elem in wc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c a b

priority_queue::difference_type (STL/CLR)

Types d’une distance signée entre deux éléments.

Syntaxe

typedef int difference_type;

Notes

Le type décrit un nombre d’éléments potentiellement négatif.

Exemple

// cliext_priority_queue_difference_type.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute negative difference
    Mypriority_queue::difference_type diff = c1.size();
    c1.push(L'd');
    c1.push(L'e');
    diff -= c1.size();
    System::Console::WriteLine("pushing 2 = {0}", diff);

    // compute positive difference
    diff = c1.size();
    c1.pop();
    c1.pop();
    c1.pop();
    diff -= c1.size();
    System::Console::WriteLine("popping 3 = {0}", diff);
    return (0);
    }

c a b
pushing 2 = -2
popping 3 = 3

priority_queue::empty (STL/CLR)

Vérifie l'absence d'éléments.

Syntaxe

bool empty();

Notes

La fonction membre retourne la valeur true pour une séquence contrôlée vide. Elle équivaut à priority_queue ::size (STL/CLR).() == 0 Vous l’utilisez pour tester si la priority_queue est vide.

Exemple

// cliext_priority_queue_empty.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.pop();
    c1.pop();
    c1.pop();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

c a b
size() = 3
empty() = False
size() = 0
empty() = True

priority_queue::generic_container (STL/CLR)

Type de l’interface générique pour le conteneur.

Syntaxe

typedef Microsoft::VisualC::StlClr::IPriorityQueue<Value>
    generic_container;

Notes

Le type décrit l’interface générique pour cette classe d’adaptateur de conteneur de modèle.

Exemple

// cliext_priority_queue_generic_container.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Mypriority_queue::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1->get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->push(L'd');
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify original and display generic
    c1.push(L'e');
    for each (wchar_t elem in gc1->get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c a b
c a b
d c b a
e d b a c

priority_queue::generic_value (STL/CLR)

Type d’un élément à utiliser avec l’interface générique du conteneur.

Syntaxe

typedef GValue generic_value;

Notes

Le type décrit un objet de type GValue qui décrit la valeur de l’élément stocké à utiliser avec l’interface générique pour cette classe de conteneur de modèle. (GValue est un value_type type ref ou value_type^ s’il s’agit value_type d’un type ref.)

Exemple

// cliext_priority_queue_generic_value.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get interface to container
    Mypriority_queue::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1->get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display in priority order using generic_value
    for (; !gc1->empty(); gc1->pop())
        {
        Mypriority_queue::generic_value elem = gc1->top();

        System::Console::Write("{0} ", elem);
        }
    System::Console::WriteLine();
    return (0);
    }

c a b
c a b
c b a

priority_queue::get_container (STL/CLR)

Accède au conteneur sous-jacent.

Syntaxe

container_type get_container();

Notes

La fonction membre retourne le conteneur sous-jacent. Vous l’utilisez pour contourner les restrictions imposées par le wrapper de conteneur.

Exemple

// cliext_priority_queue_get_container.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c a b

priority_queue::operator= (STL/CLR)

Remplace la séquence contrôlée.

Syntaxe

priority_queue <Value, Container>% operator=(priority_queue <Value, Container>% right);

Paramètres

right
Adaptateur de conteneur à copier.

Notes

L’opérateur membre copie le droit vers l’objet, puis retourne *this. Vous l’utilisez pour remplacer la séquence contrôlée par une copie de la séquence contrôlée à droite.

Exemple

// cliext_priority_queue_operator_as.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    Mypriority_queue c2;
    c2 = c1;
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c a b
c a b

priority_queue::pop (STL/CLR)

Supprime l’élément de proirité le plus élevé.

Syntaxe

void pop();

Notes

La fonction membre supprime l’élément de priorité la plus élevée de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour raccourcir la file d’attente d’un élément à l’arrière.

Exemple

// cliext_priority_queue_pop.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // pop an element and redisplay
    c1.pop();
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c a b
b a

priority_queue::priority_queue (STL/CLR)

Construit un objet d’adaptateur de conteneur.

Syntaxe

priority_queue();
priority_queue(priority_queue<Value, Container> right);
priority_queue(priority_queue<Value, Container> right);
explicit priority_queue(value_compare^ pred);
priority_queue(value_compare^ pred, container_type% cont);
template<typename InIt>
    priority_queue(InIt first, InIt last);
template<typename InIt>
    priority_queue(InIt first, InIt last,
        value_compare^ pred);
template<typename InIt>
    priority_queue(InIt first, InIt last,
        value_compare^ pred, container_type% cont);

Paramètres

cont
Conteneur à copier.

first
Début de la plage à insérer.

last
Fin de la plage à insérer.

Pred
Classement du prédicat pour la séquence contrôlée.

right
Objet ou plage à insérer.

Notes

Constructeur :

priority_queue();

crée un conteneur encapsulé vide, avec le prédicat de classement par défaut. Vous l’utilisez pour spécifier une séquence contrôlée initiale vide, avec le prédicat de classement par défaut.

Constructeur :

priority_queue(priority_queue<Value, Container>% right);

crée un conteneur encapsulé qui est une copie de right.get_container(), avec le prédicat right.value_comp()de classement . Vous l’utilisez pour spécifier une séquence contrôlée initiale qui est une copie de la séquence contrôlée par l’objet file d’attente à droite, avec le même prédicat de classement.

Constructeur :

priority_queue(priority_queue<Value, Container>^ right);

crée un conteneur encapsulé qui est une copie de right->get_container(), avec le prédicat right->value_comp()de classement . Vous l’utilisez pour spécifier une séquence contrôlée initiale qui est une copie de la séquence contrôlée par l’objet *rightfile d’attente, avec le même prédicat de classement.

Constructeur :

explicit priority_queue(value_compare^ pred);

crée un conteneur encapsulé vide, avec le prédicat de classement prédicat. Vous l’utilisez pour spécifier une séquence contrôlée initiale vide, avec le prédicat de classement spécifié.

Constructeur :

priority_queue(value_compare^ pred, container_type cont);

crée un conteneur encapsulé vide, avec le prédicat de classement prédéfini, puis envoie (push) tous les éléments de cont You use it pour spécifier une séquence contrôlée initiale à partir d’un conteneur existant, avec le prédicat de classement spécifié.

Constructeur :

template<typename InIt> priority_queue(InIt first, InIt last);

crée un conteneur encapsulé vide, avec le prédicat de classement par défaut, puis envoie (push) la séquence [first, last). Vous l’utilisez pour spécifier une séquence contrôlée initiale à partir d’une eqeuence spécifiée, avec le prédicat de classement spécifié.

Constructeur :

template<typename InIt> priority_queue(InIt first, InIt last, value_compare^ pred);

crée un conteneur encapsulé vide, avec le prédicat de classement prédicat , puis envoie (push) la séquence [first, last). Vous l’utilisez pour spécifier une séquence contrôlée initiale à partir d’une seqeuence spécifiée, avec le prédicat de classement spécifié.

Constructeur :

template<typename InIt> priority_queue(InIt first, InIt last, value_compare^ pred, container_type% cont);

crée un conteneur encapsulé vide, avec le prédicat de classement prédicat , puis envoie (push) tous les éléments de la séquence [first, last). Vous l’utilisez pour spécifier une séquence contrôlée initiale à partir d’un conteneur existant et d’une seqeuence spécifiée, avec le prédicat de classement spécifié.

Exemple

// cliext_priority_queue_construct.cpp
// compile with: /clr
#include <cliext/queue>
#include <cliext/deque>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
typedef cliext::deque<wchar_t> Mydeque;
int main()
    {
// construct an empty container
    Mypriority_queue c1;
    Mypriority_queue::container_type^ wc1 = c1.get_container();
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');
    for each (wchar_t elem in wc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule
    Mypriority_queue c2 = cliext::greater<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    for each (wchar_t elem in wc1)
        c2.push(elem);
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule by copying an underlying container
    Mypriority_queue c2x =
        gcnew Mypriority_queue(cliext::greater<wchar_t>(), *wc1);
   for each (wchar_t elem in c2x.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range
    Mypriority_queue c3(wc1->begin(), wc1->end());
    for each (wchar_t elem in c3.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule
    Mypriority_queue c4(wc1->begin(), wc1->end(),
        cliext::greater<wchar_t>());
    for each (wchar_t elem in c4.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range, another container, and an ordering rule
    Mypriority_queue c5(wc1->begin(), wc1->end(),
        cliext::greater<wchar_t>(), *wc1);
    for each (wchar_t elem in c5.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct from a generic container
    Mypriority_queue c6(c3);
    for each (wchar_t elem in c6.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    Mypriority_queue c7(%c3);
    for each (wchar_t elem in c7.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule, by copying an underlying container
    Mypriority_queue c8 =
        gcnew Mypriority_queue(cliext::greater<wchar_t>(), *wc1);
    for each (wchar_t elem in c8.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
    }

size() = 0
c a b
size() = 0
a c b
a c b
c a b
a c b
a a b c c b
c a b
c a b
a c b

priority_queue::push (STL/CLR)

Ajoute un nouvel élément.

Syntaxe

void push(value_type val);

Notes

La fonction membre insère un élément avec une valeur val dans la séquence contrôlée et réorganise la séquence contrôlée pour maintenir la discipline du tas. Vous l’utilisez pour ajouter un autre élément à la file d’attente.

Exemple

// cliext_priority_queue_push.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c a b

priority_queue::reference (STL/CLR)

Type d'une référence à un élément.

Syntaxe

typedef value_type% reference;

Notes

Le type décrit une référence à un élément.

Exemple

// cliext_priority_queue_reference.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify top of priority_queue and redisplay
    Mypriority_queue::reference ref = c1.top();
    ref = L'x';
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c a b
x a b

priority_queue::size (STL/CLR)

Compte le nombre d'éléments.

Syntaxe

size_type size();

Notes

La fonction membre retourne la longueur de la séquence contrôlée. Vous l’utilisez pour déterminer le nombre d’éléments actuellement dans la séquence contrôlée. Si tout ce dont vous vous souciez est de savoir si la séquence a une taille différente de zéro, consultez priority_queue ::empty (STL/CLR)().

Exemple

// cliext_priority_queue_size.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

    // pop an item and reinspect
    c1.pop();
    System::Console::WriteLine("size() = {0} after popping", c1.size());

    // add two elements and reinspect
    c1.push(L'a');
    c1.push(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

c a b
size() = 3 starting with 3
size() = 2 after popping
size() = 4 after adding 2

priority_queue::size_type (STL/CLR)

Type d’une distance signée entre deux éléments.

Syntaxe

typedef int size_type;

Notes

Le type décrit un nombre d’éléments non négatifs.

Exemple

// cliext_priority_queue_size_type.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    Mypriority_queue::size_type diff = c1.size();
    c1.pop();
    c1.pop();
    diff -= c1.size();
    System::Console::WriteLine("size difference = {0}", diff);
    return (0);
    }

c a b
size difference = 2

priority_queue::to_array (STL/CLR)

Copie la séquence contrôlée dans un nouveau tableau.

Syntaxe

cli::array<Value>^ to_array();

Notes

La fonction membre retourne un tableau contenant la séquence contrôlée. Vous l’utilisez pour obtenir une copie de la séquence contrôlée sous forme de tableau.

Exemple

// cliext_priority_queue_to_array.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.push(L'd');
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

d c b a
c a b

priority_queue::top (STL/CLR)

Accède à l’élément de priorité la plus élevée.

Syntaxe

reference top();

Notes

La fonction membre retourne une référence à l’élément supérieur (priorité la plus élevée) de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour accéder à l’élément de priorité la plus élevée, lorsque vous savez qu’il existe.

Exemple

// cliext_priority_queue_top.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last item
    System::Console::WriteLine("top() = {0}", c1.top());

    // alter last item and reinspect
    c1.top() = L'x';
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

priority_queue::top_item (STL/CLR)

Accède à l’élément de priorité la plus élevée.

Syntaxe

property value_type back_item;

Notes

La propriété accède à l’élément supérieur (priorité la plus élevée) de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour lire ou écrire l’élément de priorité la plus élevée, lorsque vous savez qu’il existe.

Exemple

// cliext_priority_queue_top_item.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last item
    System::Console::WriteLine("top_item = {0}", c1.top_item);

    // alter last item and reinspect
    c1.top_item = L'x';
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c a b
top_item = c
x a b

priority_queue::value_comp (STL/CLR)

Copie le délégué de classement pour deux éléments.

Syntaxe

value_compare^ value_comp();

Notes

La fonction membre retourne le délégué de classement utilisé pour commander la séquence contrôlée. Vous l’utilisez pour comparer deux valeurs.

Exemple

// cliext_priority_queue_value_comp.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    Mypriority_queue::value_compare^ vcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        vcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        vcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        vcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Mypriority_queue c2 = cliext::greater<wchar_t>();
    vcomp = c2.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        vcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        vcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        vcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

priority_queue::value_compare (STL/CLR)

Délégué de classement pour deux valeurs.

Syntaxe

binary_delegate<value_type, value_type, int> value_compare;

Notes

Le type est un synonyme du délégué qui détermine si le premier argument est classé avant la seconde.

Exemple

// cliext_priority_queue_value_compare.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    Mypriority_queue::value_compare^ vcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        vcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        vcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        vcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Mypriority_queue c2 = cliext::greater<wchar_t>();
    vcomp = c2.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        vcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        vcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        vcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

priority_queue::value_type (STL/CLR)

Type d’un élément.

Syntaxe

typedef Value value_type;

Notes

Le type est un synonyme de la valeur du paramètre de modèle.

Exemple

// cliext_priority_queue_value_type.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display reversed contents " a b c" using value_type
    for (; !c1.empty(); c1.pop())
        {   // store element in value_type object
        Mypriority_queue::value_type val = c1.top();

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

c b a

Partager via

priority_queue (STL/CLR)

Syntaxe

Paramètres

Spécifications

Déclarations

Interfaces

Notes

Membres

priority_queue::assign (STL/CLR)

Syntaxe

Paramètres

Notes

Exemple

priority_queue::const_reference (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::container_type (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::difference_type (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::empty (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::generic_container (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::generic_value (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::get_container (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::operator= (STL/CLR)

Syntaxe

Paramètres

Notes

Exemple

priority_queue::pop (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::priority_queue (STL/CLR)

Syntaxe

Paramètres

Notes

Exemple

priority_queue::push (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::reference (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::size (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::size_type (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::to_array (STL/CLR)

Syntaxe

Notes

Exemple

priority_queue::top (STL/CLR)

Syntaxe

Notes

Exemple