priority_queue (STL/CLR)

项目
04/03/2023

此模板类描述了一个对象，该对象控制一个具有受限访问权限的变长有序元素序列。使用容器适配器 priority_queue 将基础容器作为优先级队列进行管理。

在下面的描述中，GValue 与 Value 相同，除非后者是 ref 类型，在这种情况下它是 Value^。同样，GContainer 与 Container 相同，除非后者是 ref 类型，在这种情况下它是 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)	移除最高优先级元素。
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)	复制两个元素的排序委托。

properties	说明
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) 和 vector (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 类型的对象，该对象描述可与此模板容器类的泛型接口一起使用的存储元素值。（如果 value_type 是 ref 类型，则 GValue 是 value_type 或 value_type^。）

示例

// 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
要复制的容器适配器。

备注

成员运算符将 right 复制到对象，然后返回 *this。用于将受控序列替换为 right 中的受控序列的副本。

示例

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

移除最高优先级的元素。

语法

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

参数

cont
用于复制的容器。

first
要插入的范围的开头。

last
要插入的范围的末尾。

pred
受控序列的排序谓词。

right
要插入的对象或范围。

注解

构造函数：

priority_queue();

使用默认的排序谓词创建一个空的包装容器。可以用它来指定一个具有默认排序谓词的空的初始受控序列。

构造函数：

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

创建一个包装容器，它是 right.get_container() 的副本，具有排序谓词 right.value_comp()。用于指定一个初始受控序列，该序列是由队列对象 right 控制的序列的副本，具有相同的排序谓词。

构造函数：

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

创建一个包装容器，它是 right->get_container() 的副本，具有排序谓词 right->value_comp()。用于指定一个初始受控序列，该序列是由队列对象 *right 控制的序列的副本，具有相同的排序谓词。

构造函数：

explicit priority_queue(value_compare^ pred);

使用一个空的包装容器，具有排序谓词 pred。用于指定一个具有指定排序谓词的空的初始受控序列。

构造函数：

priority_queue(value_compare^ pred, container_type cont);

创建一个带有排序谓词 pred 的空包装容器，然后推送 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);

创建一个带有排序谓词 pred 的空包装容器，然后推送序列 [first, last)。你可以使用它从指定的 seqeuence 中指定一个初始受控序列，其中包含指定的排序谓词。

构造函数：

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

创建一个带有排序谓词 pred 的空包装容器，然后推送 cont 的所有元素以及序列 [first, last)。用于指定来自现有容器的初始受控序列和指定的序列，其中包含指定的排序谓词。

示例

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

备注

成员函数返回对受控序列的顶级（最高优先级）元素的引用，该元素必须为非空元素。当知道它存在时，可以使用它访问最高优先级元素。

示例

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