priority_queue (STL/CLR)

範本類別描述一個物件，控制具有有限存取權之元素的不同長度排序序列。 您可以使用容器配接器 priority_queue 來管理基礎容器作為優先順序佇列。

在下列描述中， GValue 除非後者是 ref 類型，否則會與 Value 相同，在此情況下為 Value^ 。 同樣地， GContainer 除非後者是 ref 類型，否則會與 Container 相同，在此情況下為 Container^ 。

語法

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

參數

值
受控制序列中項目的類型。

容器
基礎容器的類型。

需求

標頭： < cliext/queue>

命名空間： cliext

宣告

類型定義	描述
priority_queue::const_reference (STL/CLR)	項目的常數參考類型。
priority_queue::container_type (STL/CLR)	基礎容器的類型。
priority_queue::difference_type (STL/CLR)	兩個項目之間帶正負號距離的類型。
priority_queue::generic_container (STL/CLR)	容器配接器的泛型介面類別型。
priority_queue::generic_value (STL/CLR)	容器配接器之泛型介面的專案型別。
priority_queue::reference (STL/CLR)	項目的參考類型。
priority_queue::size_type (STL/CLR)	兩個項目之間帶正負號距離的類型。
priority_queue::value_compare (STL/CLR)	兩個專案的排序委派。
priority_queue::value_type (STL/CLR)	元素的類型。

成員函式	描述
priority_queue::assign (STL/CLR)	取代所有項目。
priority_queue::empty (STL/CLR)	測試項目是否不存在。
priority_queue::get_container (STL/CLR)	存取基礎容器。
priority_queue::pop (STL/CLR)	移除 hghest-priority 元素。
priority_queue::priority_queue (STL/CLR)	建構容器物件。
priority_queue::push (STL/CLR)	加入新的專案。
priority_queue::size (STL/CLR)	計算元素的數目。
priority_queue::top (STL/CLR)	存取最高優先順序的專案。
priority_queue::to_array (STL/CLR)	將受控制序列複製到新的陣列。
priority_queue::value_comp (STL/CLR)	複製兩個專案的排序委派。

屬性	說明
priority_queue::top_item (STL/CLR)	存取最高優先順序的專案。

運算子	描述
priority_queue::operator= (STL/CLR)	取代受控制的序列。

介面

介面	描述
ICloneable	複製 物件。
IPriorityQueue < 值，容器>	維護泛型容器配接器。

備註

物件會透過類型 為 的基礎容器，配置並釋放它所控制之序列的儲存體， Container 其會儲存 Value 元素並視需要成長。 它會將順序保留為堆積，具有最高優先順序元素（最上層元素）可輕易存取和卸載式。 物件會限制推送新元素並只快顯最高優先順序元素的存取權，並實作優先順序佇列。

物件會呼叫類型為 priority_queue：：value_compare （STL/CLR） 類型的 預存委派物件，以排序它所控制的順序。 當您建構priority_queue時，可以指定預存的委派物件;如果您未指定委派物件，則預設值為比較 operator<(value_type, value_type) 。 您可以藉由呼叫成員函 式priority_queue：：value_comp （STL/CLR） () 來存取此儲存的物件。

這類委派物件必須對類型 priority_queue：：value_type （STL/CLR） 的值施加嚴格的弱式排序。 這表示，針對任何兩個索引鍵 X 和 Y ：

value_comp()(X, Y) 會在每個呼叫上傳回相同的布林值結果。

如果 value_comp()(X, Y) 為 true，則 value_comp()(Y, X) 必須是 false。

如果 value_comp()(X, Y) 為 true，則 X 表示會在 之前 Y 排序。

如果 !value_comp()(X, Y) && !value_comp()(Y, X) 為 true，則 X 表示 Y 具有對等的排序。

對於受控制序列中之前 Y 的任何專案 X ， key_comp()(Y, X) 為 false。 （針對預設委派物件，索引鍵永遠不會減少值。）

因此，最高優先順序專案是其中一個元素，該元素不會在任何其他元素之前排序。

因為基礎容器會將排序的專案保留為堆積：

容器必須支援隨機存取反覆運算器。

具有對等排序的專案可能會以不同于推送的順序彈出。 （順序不穩定。

因此，基礎容器的候選項目包括 deque （STL/CLR） 和 向量 （STL/CLR）。

成員

priority_queue::assign (STL/CLR)

取代所有項目。

語法

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

參數

right
要插入的容器配接器。

備註

成員函式會 right.get_container() 指派給基礎容器。 您可以使用它來變更佇列的整個內容。

範例

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

項目的常數參考類型。

語法

typedef value_type% const_reference;

備註

此類型描述專案的常數參考。

範例

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

基礎容器的類型。

語法

typedef Container value_type;

備註

此類型是範本參數 Container的同義字。

範例

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

兩個專案之間帶正負號距離的類型。

語法

typedef int difference_type;

備註

型別描述可能的負元素計數。

範例

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

測試項目是否不存在。

語法

bool empty();

備註

成員函式會對空的受控制序列傳回 true。 它相當於 priority_queue：：size （STL/CLR） () == 0 。 您可以使用它來測試priority_queue是否為空白。

範例

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

容器之泛型介面的類型。

語法

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

備註

此類型描述此範本容器配接器類別的泛型介面。

範例

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

要與容器之泛型介面搭配使用的元素型別。

語法

typedef GValue generic_value;

備註

此類型描述 型 GValue 別的物件，該物件描述要與這個範本容器類別之泛型介面搭配使用的預存專案值。 （ GValue 是 value_type 或 value_type^ 如果 value_type 是 ref 類型。）

範例

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

存取基礎容器。

語法

container_type get_container();

備註

成員函式會傳回基礎容器。 您可以使用它來略過容器包裝函式所施加的限制。

範例

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

取代受控制的序列。

語法

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

參數

right
要複製的容器配接器。

備註

成員運算子會將 許可權 複製到 物件，然後傳 *this 回 。 您可以使用它，將受控制序列取代為右側 受控制序列 的複本。

範例

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

移除最高 proirity 元素。

語法

void pop();

備註

成員函式會移除受控制序列的最高優先順序元素，該元素必須是非空白的。 您可以使用它，將佇列縮短一個元素。

範例

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

建構容器配接器物件。

語法

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

參數

續
要複製的容器。

first
要插入的範圍開頭。

last
要插入的範圍結尾。

Pred
排序受控制序列的述詞。

right
要插入的物件或範圍。

備註

建構函式：

priority_queue();

使用預設排序述詞，建立空的包裝容器。 您可以使用它來指定空的初始控制序列，並使用預設順序述詞。

建構函式：

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

會建立包裝的容器，其為 的複本 right.get_container() ，並具有排序述 right.value_comp() 詞 。 您可以使用它來指定初始受控制序列，這是由佇列物件 控制之序列的 複本，且具有相同順序述詞。

建構函式：

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

會建立包裝的容器，其為 的複本 right->get_container() ，並具有排序述 right->value_comp() 詞 。 您可以使用它來指定初始受控制序列，這是由佇列物件 *right 所控制之序列的複本，其順序相同。

建構函式：

explicit priority_queue(value_compare^ pred);

使用排序述詞述 詞來 建立空的包裝容器。 您可以使用它來指定空的初始控制序列，並指定順序述詞。

建構函式：

priority_queue(value_compare^ pred, container_type cont);

使用排序述詞述 詞 來建立空的包裝容器，然後推送 cont 的所有元素 ：您可以使用它從現有的容器指定初始受控制序列，並搭配指定的排序述詞。

建構函式：

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

使用預設順序述詞建立空包裝的容器，然後推送序列 [ first ， last ]。 您可以使用它來指定指定之 eqeuence 的初始受控制序列，以及指定的排序述詞。

建構函式：

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

使用排序述詞述 詞 來建立空的包裝容器，然後推送序列 [ first ， last ]。 您可以使用它，從指定的 seqeuence 指定初始受控制序列，並搭配指定的排序述詞。

建構函式：

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

使用述詞述詞的排序述 詞 ，建立空的包裝容器，然後推送 cont 的所有元素 加上序列 [ first ， last ]。 您可以使用它，透過指定的排序述詞，從現有的容器和指定的 seqeuence 指定初始控制序列。

範例

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

加入新的專案。

語法

void push(value_type val);

備註

成員函式會將具有值的 val 元素插入至受控制序列，並重新排序受控制序列，以維護堆積專業領域。 您可以使用它將另一個專案新增至佇列。

範例

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

項目的參考類型。

語法

typedef value_type% reference;

備註

此類型描述專案的參考。

範例

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

計算元素的數目。

語法

size_type size();

備註

成員函式會傳回受控制序列的長度。 您可以使用它來判斷目前在受控制序列中的元素數目。 如果您關心的只是序列是否有非零大小，請參閱 priority_queue：：empty （STL/CLR） () 。

範例

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

兩個專案之間帶正負號距離的類型。

語法

typedef int size_type;

備註

此類型描述非負數專案計數。

範例

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

將受控制序列複製到新的陣列。

語法

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

備註

成員函式會傳回包含受控制序列的陣列。 您可以使用它，以陣列形式取得受控制序列的複本。

範例

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

存取最高優先順序的專案。

語法

reference top();

備註

成員函式會傳回受控制序列之 top （high-priority） 元素的參考，該元素必須是非空白的。 當您知道元素存在時，您可以使用它來存取最高優先順序的專案。

範例

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

存取最高優先順序的專案。

語法

property value_type back_item;

備註

屬性會存取受控制序列的最上層（最高優先順序）元素，該元素必須是非空白的。 當您知道元素存在時，您可以使用它來讀取或寫入最高優先順序的專案。

範例

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

複製兩個專案的排序委派。

語法

value_compare^ value_comp();

備註

成員函式會傳回用來排序受控制序列的排序委派。 您可以使用它來比較兩個值。

範例

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

兩個值的排序委派。

語法

binary_delegate<value_type, value_type, int> value_compare;

備註

此類型與委派同義，可判斷第一個引數是否在第二個引數之前排序。

範例

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

元素的類型。

語法

typedef Value value_type;

備註

此類型與範本參數 Value 同義。

範例

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