priority_queue (STL/CLR)

Die Vorlagenklasse beschreibt ein Objekt, das eine geordnete Reihenfolge von Elementen mit eingeschränktem Zugriff steuert. Sie verwenden den Containeradapter priority_queue , um einen zugrunde liegenden Container als Prioritätswarteschlange zu verwalten.

In der nachstehenden Beschreibung entspricht der Wert, es sei denn, GValue letzteres ist ein Bezugstyp, in diesem Fall ist Value^es . Ebenso ist dies mit Container identisch, es sei denn, GContainer letzteres ist ein Verweistyp, in diesem Fall ist Container^es .

Syntax

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

Parameter

Wert
Der Typ eines Elements in der kontrollierten Sequenz.

Container
Der Typ des zugrunde liegenden Containers.

Anforderungen

Header:<cliext/queue>

Namespace: cliext

Deklarationen

Typendefinition	Beschreibung
priority_queue::const_reference (STL/CLR)	Der Typ eines konstanten Verweises auf ein Element.
priority_queue::container_type (STL/CLR)	Der Typ des zugrunde liegenden Containers.
priority_queue::difference_type (STL/CLR)	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
priority_queue::generic_container (STL/CLR)	Der Typ der generischen Schnittstelle für den Containeradapter.
priority_queue::generic_value (STL/CLR)	Der Typ eines Elements für die generische Schnittstelle für den Containeradapter.
priority_queue::reference (STL/CLR)	Der Typ eines Verweises auf ein Element.
priority_queue::size_type (STL/CLR)	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
priority_queue::value_compare (STL/CLR)	Der Sortierdelegat für zwei Elemente.
priority_queue::value_type (STL/CLR)	Der Typ eines Elements.

Memberfunktion	Beschreibung
priority_queue::assign (STL/CLR)	Ersetzt alle Elemente.
priority_queue::empty (STL/CLR)	Testet, ob keine Elemente vorhanden sind.
priority_queue::get_container (STL/CLR)	Greift auf den zugrunde liegenden Container zu.
priority_queue::pop (STL/CLR)	Entfernt das Hghest-Priority-Element.
priority_queue::priority_queue (STL/CLR)	Erstellt ein container-Objekt.
priority_queue::push (STL/CLR)	Fügt ein neues Element hinzu.
priority_queue::size (STL/CLR)	Ermittelt die Anzahl von Elementen.
priority_queue::top (STL/CLR)	Greift auf das Element mit der höchsten Priorität zu.
priority_queue::to_array (STL/CLR)	Kopiert die kontrollierte Sequenz in ein neues Array.
priority_queue::value_comp (STL/CLR)	Kopiert den Sortierdelegat für zwei Elemente.

Eigenschaft	Beschreibung
priority_queue::top_item (STL/CLR)	Greift auf das Element mit der höchsten Priorität zu.

Operator	Beschreibung
priority_queue::operator= (STL/CLR)	Ersetzt die kontrollierte Sequenz.

Schnittstellen

Schnittstelle	Beschreibung
ICloneable	Duplizieren Eines Objekts.
IPriorityQueue-Wert<, Container>	Verwalten Sie einen generischen Containeradapter.

Hinweise

Das Objekt reserviert und gibt Speicherplatz für die Sequenz frei, die es steuert, über einen zugrunde liegenden Container vom Typ Container, der Elemente speichert Value und bei Bedarf wächst. Sie behält die Reihenfolge als Heap bei, wobei das Element mit der höchsten Priorität (dem obersten Element) leicht zugänglich und wechselbar ist. Das Objekt schränkt den Zugriff auf pushende neue Elemente ein und setzt nur das Element mit der höchsten Priorität ein, wobei eine Prioritätswarteschlange implementiert wird.

Das Objekt sortiert die Reihenfolge, die es steuert, indem ein gespeichertes Delegatobjekt vom Typ priority_queue::value_compare (STL/CLR) aufgerufen wird. Sie können das gespeicherte Delegatobjekt angeben, wenn Sie das priority_queue erstellen. wenn Sie kein Delegatobjekt angeben, ist der Standardwert der Vergleich operator<(value_type, value_type). Sie greifen auf dieses gespeicherte Objekt zu, indem Sie die Memberfunktion priority_queue::value_comp (STL/CLR)() aufrufen.

Ein solches Delegatobjekt muss eine strenge schwache Sortierung für Werte vom Typ priority_queue::value_type (STL/CLR) auferlegen. Dies bedeutet, dass für alle zwei Schlüssel X und Y:

value_comp()(X, Y) gibt dasselbe boolesche Ergebnis für jeden Anruf zurück.

Ist value_comp()(X, Y) "true", muss " value_comp()(Y, X) false" angegeben werden.

Wenn value_comp()(X, Y) dies der Fall ist, wird gesagt, X dass sie vorher Ybestellt werden.

Wenn !value_comp()(X, Y) && !value_comp()(Y, X) dies der Fall ist, dann und Y wird davon gesprochen, X dass sie eine gleichwertige Sortierung haben.

Für jedes Element X , das in der kontrollierten Sequenz vorausgeht Y , key_comp()(Y, X) ist "false". (Für das Standarddelegatobjekt verringern die Schlüssel niemals den Wert.)

Das Element mit der höchsten Priorität ist somit eines der Elemente, die nicht vor einem anderen Element angeordnet sind.

Da der zugrunde liegende Container Elemente als Heap sortiert hält:

Der Container muss Iteratoren für den zufälligen Zugriff unterstützen.

Elemente mit entsprechender Reihenfolge können in einer anderen Reihenfolge angezeigt werden, als sie verschoben wurden. (Die Sortierung ist nicht stabil.)

Daher enthalten kandidaten für den zugrunde liegenden Container deque (STL/CLR) und vector (STL/CLR).

Member

priority_queue::assign (STL/CLR)

Ersetzt alle Elemente.

Syntax

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

Parameter

right
Containeradapter, der eingefügt werden soll.

Hinweise

Die Memberfunktion weist right.get_container() dem zugrunde liegenden Container zu. Sie verwenden es, um den gesamten Inhalt der Warteschlange zu ändern.

Beispiel

// 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)

Der Typ eines konstanten Verweises auf ein Element.

Syntax

typedef value_type% const_reference;

Hinweise

Der Typ beschreibt einen Konstantenverweis auf ein Element.

Beispiel

// 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)

Der Typ des zugrunde liegenden Containers.

Syntax

typedef Container value_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Containerdar.

Beispiel

// 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)

Die Typen eines signierten Abstands zwischen zwei Elementen.

Syntax

typedef int difference_type;

Hinweise

Der Typ beschreibt eine möglicherweise negative Elementanzahl.

Beispiel

// 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)

Testet, ob keine Elemente vorhanden sind.

Syntax

bool empty();

Hinweise

Die Memberfunktion gibt „true“ für eine leere gesteuerte Sequenz zurück. Es entspricht priority_queue::size (STL/CLR)() == 0. Sie verwenden es, um zu testen, ob die priority_queue leer ist.

Beispiel

// 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)

Der Typ der generischen Schnittstelle für den Container.

Syntax

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

Hinweise

Der Typ beschreibt die generische Schnittstelle für diese Vorlagencontaineradapterklasse.

Beispiel

// 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)

Der Typ eines Elements für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef GValue generic_value;

Hinweise

Der Typ beschreibt ein Objekt vom Typ GValue , das den gespeicherten Elementwert für die Verwendung mit der generischen Schnittstelle für diese Vorlagencontainerklasse beschreibt. (GValue ist entweder value_type oder value_type^ wenn value_type es sich um einen Verweistyp handelt.)

Beispiel

// 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)

Greift auf den zugrunde liegenden Container zu.

Syntax

container_type get_container();

Hinweise

Die Memberfunktion gibt den zugrunde liegenden Container zurück. Sie verwenden sie, um die vom Containerwrapper auferlegten Einschränkungen zu umgehen.

Beispiel

// 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)

Ersetzt die kontrollierte Sequenz.

Syntax

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

Parameter

right
Containeradapter, der kopiert werden soll.

Hinweise

Der Memberoperator kopiert direkt in das Objekt und gibt dann zurück *this. Sie verwenden sie, um die kontrollierte Sequenz durch eine Kopie der gesteuerten Sequenz rechts zu ersetzen.

Beispiel

// 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)

Entfernt das Element mit der höchsten Proirität.

Syntax

void pop();

Hinweise

Die Memberfunktion entfernt das Element mit der höchsten Priorität der gesteuerten Sequenz, das nicht leer sein muss. Sie verwenden es, um die Warteschlange um ein Element im Hintergrund zu kürzen.

Beispiel

// 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)

Erstellt ein Containeradapterobjekt.

Syntax

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);

Parameter

cont
Der zu kopierende Container.

first
Anfang des einzufügenden Bereichs.

last
Ende des einzufügenden Bereichs.

Pred
Sortieren des Prädikats für die kontrollierte Sequenz.

right
Einzufügendes Objekt bzw. einzufügender Bereich.

Hinweise

Der Konstruktor:

priority_queue();

erstellt einen leeren umschlossenen Container mit dem Standardreihenfolgen-Prädikat. Sie verwenden es, um eine leere anfängliche kontrollierte Sequenz mit dem Standardreihenfolge-Prädikat anzugeben.

Der Konstruktor:

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

erstellt einen umschlossenen Container, der eine Kopie von right.get_container(), mit dem Sortier-Prädikat right.value_comp()ist. Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der Sequenz ist, die vom Warteschlangenobjekt rechts gesteuert wird, mit demselben Sortier-Prädikat.

Der Konstruktor:

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

erstellt einen umschlossenen Container, der eine Kopie von right->get_container(), mit dem Sortier-Prädikat right->value_comp()ist. Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der vom Warteschlangenobjekt *rightgesteuerten Sequenz mit demselben Sortier-Prädikat ist.

Der Konstruktor:

explicit priority_queue(value_compare^ pred);

erstellt einen leeren umschlossenen Container mit dem Prädikat für die Sortierung. Sie verwenden es, um eine leere anfängliche kontrollierte Sequenz mit dem angegebenen Sortier-Prädikat anzugeben.

Der Konstruktor:

priority_queue(value_compare^ pred, container_type cont);

erstellt einen leeren umschlossenen Container mit dem Prädikat für die Sortierreihenfolge und verschiebt dann alle Elemente von "Cont", um eine anfängliche kontrollierte Sequenz aus einem vorhandenen Container mit dem angegebenen Sortier-Prädikat anzugeben.

Der Konstruktor:

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

erstellt einen leeren umschlossenen Container mit dem Standardreihenfolgen-Prädikat und verschiebt dann die Sequenz [first, last). Sie verwenden es, um eine anfängliche kontrollierte Sequenz aus einem angegebenen Eqeuence mit dem angegebenen Sortier-Prädikat anzugeben.

Der Konstruktor:

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

erstellt einen leeren umschlossenen Container mit dem Prädikat der Sortierreihenfolge und verschiebt dann die Sequenz [first, last). Sie verwenden es, um eine anfängliche kontrollierte Sequenz aus einer angegebenen Seqeuence mit dem angegebenen Sortier-Prädikat anzugeben.

Der Konstruktor:

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

erstellt einen leeren umschlossenen Container, wobei das Order-Prädikat prädikat vorhanden ist, und verschiebt dann alle Elemente von Cont plus die Sequenz [first, last). Sie verwenden es, um eine anfängliche kontrollierte Sequenz aus einem vorhandenen Container und eine angegebene Seqeuence mit dem angegebenen Sortier-Prädikat anzugeben.

Beispiel

// 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)

Fügt ein neues Element hinzu.

Syntax

void push(value_type val);

Hinweise

Die Memberfunktion fügt ein Element mit Einem Wert val in die kontrollierte Sequenz ein und ordnet die kontrollierte Sequenz neu an, um die Heap-Disziplin beizubehalten. Sie verwenden es, um der Warteschlange ein weiteres Element hinzuzufügen.

Beispiel

// 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)

Der Typ eines Verweises auf ein Element.

Syntax

typedef value_type% reference;

Hinweise

Der Typ beschreibt einen Verweis auf ein Element.

Beispiel

// 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)

Ermittelt die Anzahl von Elementen.

Syntax

size_type size();

Hinweise

Die Memberfunktion gibt die Länge der gesteuerten Sequenz zurück. Sie verwenden es, um die Anzahl der Elemente zu bestimmen, die sich derzeit in der kontrollierten Sequenz befindet. Wenn Sie sich nur darum kümmern, ob die Sequenz keine Zerogröße aufweist, lesen Sie priority_queue::empty (STL/CLR)().

Beispiel

// 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)

Der Typ eines signierten Abstands zwischen zwei Elementen.

Syntax

typedef int size_type;

Hinweise

Der Typ beschreibt eine nicht negative Elementanzahl.

Beispiel

// 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)

Kopiert die kontrollierte Sequenz in ein neues Array.

Syntax

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

Hinweise

Die Memberfunktion gibt ein Array zurück, das die kontrollierte Sequenz enthält. Sie verwenden es, um eine Kopie der kontrollierten Sequenz in Arrayform abzurufen.

Beispiel

// 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)

Greift auf das Element mit der höchsten Priorität zu.

Syntax

reference top();

Hinweise

Die Memberfunktion gibt einen Verweis auf das oberste Element (höchste Priorität) der kontrollierten Sequenz zurück, das nicht leer sein muss. Sie verwenden es, um auf das Element mit der höchsten Priorität zuzugreifen, wenn Sie wissen, dass es vorhanden ist.

Beispiel

// 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)

Greift auf das Element mit der höchsten Priorität zu.

Syntax

property value_type back_item;

Hinweise

Die Eigenschaft greift auf das oberste Element (höchste Priorität) der kontrollierten Sequenz zu, die nicht leer sein muss. Sie verwenden es, um das Element mit der höchsten Priorität zu lesen oder zu schreiben, wenn Sie wissen, dass es vorhanden ist.

Beispiel

// 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)

Kopiert den Sortierdelegat für zwei Elemente.

Syntax

value_compare^ value_comp();

Hinweise

Die Memberfunktion gibt den Sortierdelegat zurück, der zum Sortieren der gesteuerten Sequenz verwendet wird. Sie verwenden es, um zwei Werte zu vergleichen.

Beispiel

// 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)

Der Sortierdelegat für zwei Werte.

Syntax

binary_delegate<value_type, value_type, int> value_compare;

Hinweise

Der Typ ist ein Synonym für den Delegaten, der bestimmt, ob das erste Argument vor der zweiten sortiert wird.

Beispiel

// 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)

Der Typ eines Elements.

Syntax

typedef Value value_type;

Hinweise

Der Typ ist ein Synonym für den Vorlagenparameter Value.

Beispiel

// 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