如何解释优先级队列的模板签名？

Question

template <class T, class Container = vector<T>, class Compare = less<typename Container::value_type> > class priority_queue;    

I understand the first two template arguments, the first template argument is the data type of the element being stored in the priority queue and the second one is the kind of container that the programmer wants to use, it could be either deque or vector.

But the third argument confuses me a bit, because I have never seen something like it. I'd have done something like:

template <class T, class Container = vector<T>
class priority_queue{
    /* Implementation */
};

Does it have something to do with the strict weak ordering criterion necessary for priority queue? If yes, how can I learn more about it? Could you give an example of using the third argument?

I am new to template programming, so I'd really appreciate your help.

Answer 1

The third parameter specifies the comparator class.

The comparator class is responsible for comparing queue elements, in order to determine the queue order. You already understand that the elements in the queue are ordered with the "higher" values first. Well, this is what defines what "higher" means, here.

The comparator class has a simple interface: given two values, return true if the first value is less than the second value, and false otherwise. The default implementation, std::less , uses the traditional < operator to compare the two values.

Use a custom comparator class in order to change the behavior of the priority queue. One example would be to specify std::greater instead of std::less as the comparator class. std::greater uses the > operator, so this creates a priority queue "in opposite order", which gives you the lowest values first, rather than highest one.

Or, you could create your own custom comparator class, such as:

class last_four_bits {

public:

    bool operator()(int a, int b) const
    {
           return (a & 0x0F) < (b & 0x0F);
    }
};

This comparator class compares the least four bits of an int only. This, in turn, makes this:

std::priority_queue<int, std::vector<int>, last_four_bits>

look at the least four bits of each int value in the queue, thus ordering all int s with the highest values in the last four bits before the ones with the lesser values, ignoring all other bits in the int .

PS Comparator classes are also used with associative containers, set s and map s, and serve the same function there. By carefully crafting a comparator class you can create sets and maps whose iterators iterate over the keys in the set/map in some order other than the lowest to the highest keys (as you understand "lowest" and "highest" to mean, intrinsically).