容器适配器之priority_queue

/*
//construct priority_queue
priority_queue (const Compare& comp = Compare(), const Container& ctnr = Container());
priority_queue (InputIterator first, InputIterator last, const Compare& comp = Compare(), const Container& ctnr = Container());

A priority_queue keeps internally a comparing function and a container object as data, which are copies of comp and ctnr respectively.
[优先队列会将一个比较函数和一个容器对象数据，它们是各自传递到构造函数中的参数comp和ctnr]
The range version (2), on top that, inserts the elements between first and last (before the container is converted into a heap).
[第二种方式会将[first, second)之间的元素插入到优先队列中，然后转换成堆(通过make_heap排序)]

comp
Comparison object to be used to order the heap.
[comp是用于对堆进行排序的比较对象]
This may be a function pointer or function object able to perform a strict weak ordering by comparing its two arguments.
[comp可以是一个能够进行严格弱排序的函数指针或者函数对象，且有两个参数]
Compare is the third class template paramete ( by default: less<T>).
[comp的数据类型是优先队列的第三个模板参数，默认情况下为less<T>]

ctnr
Container object.
[ctnr是一个容器类对象]
Container is the second class template parameter (the type of the underlying container for the priority_queue; by default: vector<T>).
[ctnr的数据类型是优先队列的第二个模板参数，即优先队列的内在容器的类型，默认情况下为vector<T>]
*/

#include <iostream>
#include <queue>
#include <vector>
#include <functional>

class mycomparison
{
    bool reverse;
public:
    mycomparison(const bool& revparam = false)
    {
        reverse = revparam;
    }
    bool operator() (const int& lhs, const int& rhs) const
    {
        if(reverse) return (lhs>rhs);
        else return (lhs<rhs);
    }
};

int main()
{
    int myints[] = {10, 60, 50, 20};

    std::priority_queue<int> first;
    std::priority_queue<int> second(myints, myints+4);

    typedef std::priority_queue<int, std::vector<int>, mycomparison> mypq_type;

    mypq_type third;

    third.push(10);
    third.push(50);
    third.push(60);
    third.push(20);

    std::cout<<"third contains:\n";
    while(!third.empty())
    {
        std::cout<<third.top()<<‘ ‘;
        third.pop();
    }

    mypq_type fourth(myints, myints+4, mycomparison(true));

    std::cout<<"\nfourth contains:\n";
    while(!fourth.empty())
    {
        std::cout<<fourth.top()<<‘ ‘;
        fourth.pop();
    }

    std::cout<<‘\n‘;

    system("pause");
    return 0;
}

/*
bool empty() const;
size_type size() const;
void push(const value_type& val);
void pop();
const value_type& top() const;
*/

#include <iostream>
#include <queue>

int main()
{
    std::priority_queue<int> mypq;

    mypq.push(30);
    mypq.push(100);
    mypq.push(25);
    mypq.push(40);

    std::cout<<"Popping out elements...";
    while(!mypq.empty())
    {
        std::cout<<‘ ‘<<mypq.top();
        mypq.pop();
    } 

    std::cout<<‘\n‘;

    system("pause");
    return 0;
}