在第一部分中，我们借助map提供的参数接口，为它指定相应Compare类，就可以实现对map按Key排序，是在创建map并不断的向其中添加元素的过程中就会完成排序。

现在我们想要从map中得到水果价格的从低到高的次序输出，该如何实现呢？换句话说，该如何实现Map的按Value排序呢？

        第一反应是利用stl中提供的sort算法实现，这个想法是好的，不幸的是，sort算法有个限制，利用sort算法只能对序列容器进行排序，就是线性的（如vector，list，deque）。map也是一个集合容器，它里面存储的元素是pair，但是它不是线性存储的（前面提过，像红黑树），所以利用sort不能直接和map结合进行排序。

       虽然不能直接用sort对map进行排序，那么我们可不可以迂回一下，把map中的元素放到序列容器（如vector）中，然后再对这些元素进行排序呢？这个想法看似是可行的。要对序列容器中的元素进行排序，也有个必要条件：就是容器中的元素必须是可比较的，也就是实现了<操作的。那么我们现在就来看下map中的元素满足这个条件么？

       我们知道map中的元素类型为pair，具体定义如下：

template <class T1, class T2> struct pair  
{  
  typedef T1 first_type;  
  typedef T2 second_type;  
  
  T1 first;  
  T2 second;  
  pair() : first(T1()), second(T2()) {}  
  pair(const T1& x, const T2& y) : first(x), second(y) {}  
  template <class U, class V>  
    pair (const pair<U,V> &p) : first(p.first), second(p.second) { }  
}  

在<utility>头文件中，还为pair重载了 < 运算符， 具体实现如下： 

template<class _T1, class _T2>  
  inline bool  
  operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)  
  { return __x.first < __y.first  
           || (!(__y.first < __x.first) && __x.second < __y.second); }  

__x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second)  

这个less在两种情况下返回true，第一种情况：__x.first < __y.first  这个好理解，就是比较key，如果__x的key 小于 __y的key 则返回true。

第二种情况有点费解：  !(__y.first < __x.first) && __x.second < __y.second

当然由于||运算具有短路作用，即当前面的条件不满足是，才进行第二种情况的判断 。第一种情况__x.first < __y.first 不成立，即__x.first >= __y.first 成立，在这个条件下，我们来分析下  !(__y.first < __x.first)  && __x.second < __y.second

即：  !(__y.first < __x.first)  &&   !(__x.first < __y.first )   等价于   __x.first == __y.first ,也就是说，第二种情况是在key相等的情况下，比较两者的value（second）。

这里比较令人费解的地方就是，为什么不直接写 __x.first == __y.first 呢？ 这么写看似费解，但其实也不无道理：前面讲过，作为map的key必须实现<操作符的重载，但是并不保证==符也被重载了，如果key没有提供==，那么 ，__x.first == __y.first 这样写就错了。由此可见，stl中的代码是相当严谨的，值得我们好好研读。

 现在我们知道了pair类重载了<符，但是它并不是按照value进行比较的，而是先对key进行比较，key相等时候才对value进行比较。显然不能满足我们按value进行排序的要求。

而且，既然pair已经重载了<符，而且我们不能修改其实现，又不能在外部重复实现重载<符。

typedef pair<string, int> PAIR;  
bool operator< (const PAIR& lhs, const PAIR& rhs) {  
    return lhs.second < rhs.second;  
}  

那么我们如何实现对pair按value进行比较呢？ 第一种：是最原始的方法，写一个比较函数；  第二种：刚才用到了，写一个函数对象。这两种方式实现起来都比较简单。

typedef pair<string, int> PAIR;  
  
bool cmp_by_value(const PAIR& lhs, const PAIR& rhs) {  
  return lhs.second < rhs.second;  
}  
  
struct CmpByValue {  
  bool operator()(const PAIR& lhs, const PAIR& rhs) {  
    return lhs.second < rhs.second;  
  }  
};  

template <class RandomAccessIterator>  
  void sort ( RandomAccessIterator first, RandomAccessIterator last );  
  
template <class RandomAccessIterator, class Compare>  
  void sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp ); 

1. 我们看到，令人兴奋的是，sort算法和map一样，也可以让我们指定元素间如何进行比较，即指定Compare。需要注意的是，map是在定义时指定的，所以传参的时候直接传入函数对象的类名，就像指定key和value时指定的类型名一样；sort算法是在调用时指定的，需要传入一个对象，当然这个也简单，类名()就会调用构造函数生成对象。

#include<iostream>
#include<utility>//<utility>中定义了模板函数make_pair
#include<string>
#include<map>
#include<iterator>
#include<vector>
#include<algorithm>
using namespace std;

typedef pair<string, double> PAIR;  
bool cmp_by_value_less(const PAIR& l,const PAIR& r)
{
	return l.second<r.second;
}

bool cmp_by_value_greater(const PAIR& l,const PAIR& r)
{
	return l.second>r.second;
}
struct CmpByKeyLength {  
  bool operator()(const string& k1, const string& k2) {  
    return k1.length() < k2.length();  
  }  
};  
void  main()
{
	pair<string,double> fruit1("orange",4.5);//初始化
	pair<string,double> fruit2;
	pair<string,double> fruit3;

	//结构体初始化
	fruit2.first="bananas";
	fruit2.second=3.25;
    
	//使用模板函数给pair结构体赋值
	fruit3=make_pair("apple",5.2);
	/*cout<<"pair:"<<endl;
	cout<<"The price of "<<fruit1.first<<" is $"<<fruit1.second<<endl;
	cout<<"The price of "<<fruit2.first<<" is $"<<fruit2.second<<endl;
	cout<<"The price of "<<fruit3.first<<" is $"<<fruit3.second<<endl;*/

	cout<<endl<<"map:sorted by key(less)"<<endl;
	map<string,double> mapA;
	mapA.insert(fruit1);
	mapA.insert(fruit2);
	mapA.insert(fruit3);
	for(map<string,double>::iterator iter=mapA.begin();iter!=mapA.end();iter++)
	{
		cout<<"The price of "<<iter->first<<" is $"<<iter->second<<endl;
	}

	vector<PAIR> vec(mapA.begin(),mapA.end());
	sort(vec.begin(),vec.end(),cmp_by_value_less);
	cout<<endl<<"map:sorted by value(less)"<<endl;
	for(int i=0;i<vec.size();i++)
	{
		cout<<"The price of "<<vec[i].first<<" is $"<<vec[i].second<<endl;
	}

	sort(vec.begin(),vec.end(),cmp_by_value_greater);
	cout<<endl<<"map:sorted by value(greater)"<<endl;
	for(int i=0;i<vec.size();i++)
	{
		cout<<"The price of "<<vec[i].first<<" is $"<<vec[i].second<<endl;
	}

}

#include<iostream>
#include<utility>//<utility>中定义了模板函数make_pair
#include<string>
#include<map>
#include<iterator>
#include<vector>
#include<algorithm>
using namespace std;

typedef pair<string, double> PAIR;  
bool cmp_by_value_less(const PAIR& l,const PAIR& r)
{
	return l.second<r.second;
}

bool cmp_by_value_greater(const PAIR& l,const PAIR& r)
{
	return l.second>r.second;
}
struct CmpByKeyLength {  
  bool operator()(const string& k1, const string& k2) {  
    return k1.length() < k2.length();  
  }  
};  
void  main()
{
	pair<string,double> fruit1("orange",4.5);//初始化
	pair<string,double> fruit2;
	pair<string,double> fruit3;

	//结构体初始化
	fruit2.first="bananas";
	fruit2.second=3.25;
    
	//使用模板函数给pair结构体赋值
	fruit3=make_pair("apple",5.2);
	cout<<"pair:"<<endl;
	cout<<"The price of "<<fruit1.first<<" is $"<<fruit1.second<<endl;
	cout<<"The price of "<<fruit2.first<<" is $"<<fruit2.second<<endl;
	cout<<"The price of "<<fruit3.first<<" is $"<<fruit3.second<<endl;

	cout<<endl<<"map:sorted by key(less)"<<endl;
	map<string,double> mapA;
	mapA.insert(fruit1);
	mapA.insert(fruit2);
	mapA.insert(fruit3);
	for(map<string,double>::iterator iter=mapA.begin();iter!=mapA.end();iter++)
	{
		cout<<"The price of "<<iter->first<<" is $"<<iter->second<<endl;
	}

	map<string,double,greater<string>> mapB;
	mapB.insert(fruit1);
	mapB.insert(fruit2);
	mapB.insert(fruit3);
	cout<<endl<<"map:sorted by key(greater)"<<endl;
	for(map<string,double,greater<string>>::iterator iter1=mapB.begin();iter1!=mapB.end();iter1++)
	{
		cout<<"The price of "<<iter1->first<<" is $"<<iter1->second<<endl;
	}

	map<string,double, CmpByKeyLength > mapC;
	mapC.insert(fruit1);
	mapC.insert(fruit2);
	mapC.insert(fruit3);
	cout<<endl<<"map:sorted by length"<<endl;
	for(map<string,double, CmpByKeyLength >::iterator iter2=mapC.begin();iter2!=mapC.end();iter2++)
	{
		cout<<"The price of "<<iter2->first<<" is $"<<iter2->second<<endl;
	}

	vector<PAIR> vec(mapA.begin(),mapA.end());
	sort(vec.begin(),vec.end(),cmp_by_value_less);
	cout<<endl<<"map:sorted by value(less)"<<endl;
	for(int i=0;i<vec.size();i++)
	{
		cout<<"The price of "<<vec[i].first<<" is $"<<vec[i].second<<endl;
	}

	sort(vec.begin(),vec.end(),cmp_by_value_greater);
	cout<<endl<<"map:sorted by value(greater)"<<endl;
	for(int i=0;i<vec.size();i++)
	{
		cout<<"The price of "<<vec[i].first<<" is $"<<vec[i].second<<endl;
	}

}