priority_queue (STL/CLR)

Die Vorlagenklasse beschreibt ein Objekt, das eine geordnete Sequenz von Elementen mit unterschiedlicher Länge steuert, die eingeschränkten Zugriff hat. Sie verwenden den Containeradapter priority_queue , um einen zugrunde liegenden Container als Prioritätswarteschlange zu verwalten.

In der folgenden Beschreibung ist mit Value identisch, es sei denn, GValue letzteres ist ein Verweistyp, in diesem Fall ist Value^es . Auf ähnliche Weise ist 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 gesteuerte Sequenz in ein neues Array.
priority_queue::value_comp (STL/CLR)	Kopiert den Delegaten für die Sortierung 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.
IPriorityQueueValue<, Container>	Verwalten des generischen Containeradapters.

Hinweise

Das -Objekt belegt und gibt Speicher für die Sequenz frei, die es über einen zugrunde liegenden Container vom Typ Containersteuert, der Elemente speichert Value und bei Bedarf wächst. Die Sequenz bleibt als Heap sortiert, wobei das Element mit der höchsten Priorität (das oberste Element) leicht zugänglich und wechselbar ist. Das -Objekt schränkt den Zugriff auf das Pushen neuer Elemente und das Popen nur des Elements mit der höchsten Priorität ein, wobei eine Prioritätswarteschlange implementiert wird.

Das -Objekt sortiert die Sequenz, die es steuert, indem es ein gespeichertes Delegatobjekt vom Typ priority_queue::value_compare (STL/CLR) aufruft. Sie können das gespeicherte Delegatobjekt angeben, wenn Sie die 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 Reihenfolge für Werte vom Typ priority_queue::value_type (STL/CLR) vorgeben. Dies bedeutet für zwei beliebige Schlüssel X und Y:

value_comp()(X, Y) gibt bei jedem Aufruf das gleiche boolesche Ergebnis zurück.

Wenn value_comp()(X, Y) true ist, value_comp()(Y, X) muss false sein.

Wenn value_comp()(X, Y) true ist, X wird als vor Ysortiert bezeichnet.

Wenn !value_comp()(X, Y) && !value_comp()(Y, X) true ist, X werden und Y als gleichwertig bezeichnet.

Für jedes Element X , das in der kontrollierten Y Sequenz vorangestellt ist, key_comp()(Y, X) ist false. (Für das Standarddelegatobjekt verringern sich Schlüssel nie im Wert.)

Das Element mit der höchsten Priorität ist daher eines der Elemente, das vor keinem anderen Element sortiert ist.

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

Der Container muss Iteratoren mit wahlfreiem Zugriff unterstützen.

Elemente mit gleichwertiger Reihenfolge können in einer anderen Reihenfolge als per Pushvorgang per Pop übertragen werden. (Die Reihenfolge ist nicht stabil.)

Daher sind 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
Einzufügende Containeradapter.

Hinweise

Die Memberfunktion weist right.get_container() dem zugrunde liegenden Container zu. Sie verwenden sie, 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 konstanten Verweis 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 Container dar.

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 Abstands mit Vorzeichen 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. Dies entspricht priority_queue::size (STL/CLR).() == 0 Damit können Sie 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 zur 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 ein Verweistyp ist.)

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 Einschränkungen zu umgehen, die vom Containerwrapper vorgegeben werden.

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
Zu kopierende Containeradapter.

Hinweise

Der Memberoperator kopiert direkt in das -Objekt und gibt dann zurück *this. Sie verwenden sie, um die gesteuerte Sequenz durch eine Kopie der kontrollierten 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 dem höchsten Ziel.

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 sie, um die Warteschlange um ein Element auf der Rückseite zu verkü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ügende Bereichs.

last
Ende des einzufügende Bereichs.

Pred
Sortierungsprädikat 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 Standardreihenfolgeprädikat. Sie verwenden sie, um eine leere anfänglich gesteuerte Sequenz mit dem Standardreihenfolgenprädikat anzugeben.

Der Konstruktor:

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

erstellt einen umschlossenen Container, der eine Kopie von right.get_container()ist, mit dem Sortierungsprädikat right.value_comp(). Sie verwenden sie, um eine anfänglich gesteuerte Sequenz anzugeben, bei der es sich um eine Kopie der Sequenz handelt, die vom Warteschlangenobjektrecht mit dem gleichen Reihenfolgenprädikat gesteuert wird.

Der Konstruktor:

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

erstellt einen umschlossenen Container, der eine Kopie von right->get_container()ist, mit dem Sortierungsprädikat right->value_comp(). Sie verwenden sie, um eine anfänglich gesteuerte Sequenz anzugeben, bei der es sich um eine Kopie der Sequenz handelt, die vom Warteschlangenobjekt *rightmit dem gleichen Reihenfolgenprädikat gesteuert wird.

Der Konstruktor:

explicit priority_queue(value_compare^ pred);

erstellt einen leeren umschlossenen Container mit dem Prädikat für die Sortierung. Sie verwenden sie, um eine leere anfänglich gesteuerte Sequenz mit dem angegebenen Reihenfolgenprädikat anzugeben.

Der Konstruktor:

priority_queue(value_compare^ pred, container_type cont);

erstellt einen leeren umschlossenen Container mit dem Prädikat für die Sortierung als Prädikat und pusht dann alle Elemente von cont Sie verwenden ihn, um eine anfänglich kontrollierte Sequenz aus einem vorhandenen Container mit dem angegebenen Sortierprädikat anzugeben.

Der Konstruktor:

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

erstellt einen leeren umschlossenen Container mit dem Standardreihenfolgeprädikat und pusht dann die Sequenz [first, last). Sie verwenden sie, um eine anfänglich gesteuerte Sequenz aus einem angegebenen Eqeuence mit dem angegebenen Reihenfolgenprä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 für die Sortierung und pusht dann die Sequenz [first, last). Sie verwenden sie, um eine anfängliche kontrollierte Sequenz aus einem angegebenen Seqeuence mit dem angegebenen Sortierungs 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 mit dem Prädikat für die Sortierung und über pusht dann alle Elemente von cont plus der Sequenz [first, last). Sie verwenden sie, um eine anfängliche kontrollierte Sequenz aus einem vorhandenen Container und einem angegebenen Seqeuence mit dem angegebenen Sortierungs 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 val Wert in die kontrollierte Sequenz ein und ordnet die gesteuerte Sequenz neu an, um die Heapdisziplin zu verwalten. Sie verwenden sie, 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 sie, um die Anzahl der Elemente zu bestimmen, die sich derzeit in der kontrollierten Sequenz befindet. Wenn Sie nur wissen möchten, ob die Sequenz eine Größe ungleich 0 (null) hat, finden Sie weitere Informationen unter 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 Abstands mit Vorsigniert zwischen zwei -Element.

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 sie, um eine Kopie der kontrollierten Sequenz in Arrayform zu erhalten.

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)

Greifen Sie 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 darf. Sie verwenden sie, um auf das Element mit der höchsten Priorität zu zugreifen, 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)

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

Syntax

property value_type back_item;

Hinweise

Die -Eigenschaft greifen auf das oberste Element (höchste Priorität) der kontrollierten Sequenz zu, das nicht leer sein darf. 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 Delegaten für die Sortierung für zwei Elemente.

Syntax

value_compare^ value_comp();

Hinweise

Die Memberfunktion gibt den Reihenfolgendelegierten zurück, der zum Bestellen der gesteuerten Sequenz verwendet wird. Damit können Sie zwei Werte 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 Sortierungsdegat 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 dem zweiten Argument geordnet 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