构建降序的set

前言

set是stl模板中可以实现数据自动排序的容器，默认的排序方式是从小到大的升序排序，如果想要降序排序应该怎么做呢？

在网站（http://www.cplusplus.com/reference/set/set/?kw=set）中查到如下说明：

template < class T,                        // set::key_type/value_type
           class Compare = less<T>,        // set::key_compare/value_compare
           class Alloc = allocator<T>      // set::allocator_type
           > class set;

其中的各个参数为：

T

Type of the elements. Each element in a  set container is also uniquely identified by this value (each value is itself also the element's key).
Aliased as member types  set::key_type and  set::value_type.

Compare

A binary predicate that takes two arguments of the same type as the elements and returns a  bool. The expression  comp(a,b), where  comp is an object of this type and  a and  b are key values, shall return  true if  a is considered to go before  b in the  strict weak ordering the function defines.
The  set object uses this expression to determine both the order the elements follow in the container and whether two element keys are equivalent (by comparing them reflexively: they are equivalent if  !comp(a,b) && !comp(b,a)). No two elements in a  set container can be equivalent.
This can be a function pointer or a function object (see  constructor for an example). This defaults to  less<T>, which returns the same as applying the  less-than operator ( a<b).
Aliased as member types  set::key_compare and  set::value_compare.

Alloc

Type of the allocator object used to define the storage allocation model. By default, the  allocator class template is used, which defines the simplest memory allocation model and is value-independent.
Aliased as member type  set::allocator_type.

思路

其中可以看到，第二个参数Compare决定了set容器比较两个元素顺序的结果，推测如果修改这个参数就应该可以修改set的排序方式。

其默认值是为

class Compare = less<T>,        // set::key_compare/value_compare

在vs中通过f12定位到了 less<T>：

位于xstddef.h的第186行：

		// TEMPLATE STRUCT less
template<class _Ty = void>
	struct less
		: public binary_function<_Ty, _Ty, bool>
	{	// functor for operator<
	bool operator()(const _Ty& _Left, const _Ty& _Right) const
		{	// apply operator< to operands
		return (_Left < _Right);
		}
	};

如果类似的构造一个more的结构体就可以实现set的降序了。

实现及验证

通过以下的代码验证：

#include <algorithm>
#include <set>
#include <iostream>

using namespace std;

// TEMPLATE STRUCT less
template<class _Ty = void>
struct more
	: public binary_function<_Ty, _Ty, bool>
{	// functor for operator<
	bool operator()(const _Ty& _Left, const _Ty& _Right) const
	{	// apply operator< to operands
		return (_Left > _Right);
	}
};

int main()
{
	set<int, more<int>> ss;

	ss.insert(99);
	ss.insert(22);
	ss.insert(9);
	ss.insert(39);
	ss.insert(93);
	ss.insert(24);
	ss.insert(67);

	for each (int var in ss)
	{
		cout << var << " ";
	}

	return 0;
}

输出的结果为：

99 93 67 39 24 22 9

如果将第20行改为

set<int, less<int>> ss;

或

set<int> ss;

得到的结果为：

9 22 24 39 67 93 99

以上结果证明修改的方法是可行的。