map是用來存放<key, value>鍵值對的資料結構，可以很方便快速的根據key查到相應的value。假如儲存學生和其成績（假定不存在重名，當然可以對重名加以區分），我們用map來進行儲存就是個不錯的選擇。 我們這樣定義，map<string, int>，其中學生姓名用string型別，作為Key；該學生的成績用int型別，作為value。這樣一來，我們可以根據學生姓名快速的查詢到他的成績。

        但是，我們除了希望能夠查詢某個學生的成績，或許還想看看整體的情況。我們想把所有同學和他相應的成績都輸出來，並且按照我們想要的順序進行輸出：比如按照學生姓名的順序進行輸出，或者按照學生成績的高低進行輸出。換句話說，我們希望能夠對map進行按Key排序或按Value排序，然後按序輸出其鍵值對的內容。

一、C++ STL中Map的按Key排序

       其實，為了實現快速查詢，map內部本身就是按序儲存的（比如紅黑樹）。在我們插入<key, value>鍵值對時，就會按照key的大小順序進行儲存。這也是作為key的型別必須能夠進行<運算比較的原因。現在我們用string型別作為key，因此，我們的儲存就是按學生姓名的字典排序儲存的。

【參考程式碼】

1. #include<map>
2. #include<string>
3. #include<iostream>
4. usingnamespace std;  
5. typedef pair<string, 
   int> PAIR;  
6. ostream& operator<<(ostream& out, const PAIR& p) {  
7.   return out << p.first << "\t" << p.second;  
8. }  
9. int main() {  
10.   map<string, int> name_score_map;  
11.   name_score_map["LiMin"] = 90;   
12.   name_score_map["ZiLinMi"] = 79;   
13.   name_score_map["BoB"
    ] = 92;   
14.   name_score_map.insert(make_pair("Bing",99));  
15.   name_score_map.insert(make_pair("Albert",86));  
16.   for (map<string, int>::iterator iter = name_score_map.begin();  
17.        iter != name_score_map.end();  
18.        ++iter) {  
19.     cout << *iter << endl;  
20.   }  
21.   return 0;  
22.  }  

【執行結果】

大家都知道map是stl裡面的一個模板類，現在我們來看下map的定義：

1. template < class Key, class T, class Compare = less<Key>,  
2.            class Allocator = allocator<pair<const Key,T> > > class map;  

現在我們重點看下第三個引數： class Compare = less<Key> 

這也是一個class型別的，而且提供了預設值 less<Key>。 less是stl裡面的一個函式物件，那麼什麼是函式物件呢？

所謂的函式物件：即呼叫操作符的類，其物件常稱為函式物件（function object），它們是行為類似函式的物件。表現出一個函式的特徵，就是通過“物件名+(引數列表)”的方式使用一個 類，其實質是對operator()操作符的過載。

現在我們來看一下less的實現：

1. template <class T> struct less : binary_function <T,T,bool> {  
2.   bool operator() (const T& x, const T& y) const
3.     {return x<y;}  
4. };  

1. template <class T> struct greater : binary_function <T,T,bool> {  
2.   bool operator() (const T& x, const T& y) const
3.     {return x>y;}  
4. };  

我們可以在定義map的時候，指定它的第三個引數Compare，比如我們把預設的less指定為greater：

【參考程式碼】

1. #include<map>
2. #include<string>
3. #include<iostream>
4. usingnamespace std;  
5. typedef pair<string, int> PAIR;  
6. ostream& operator<<(ostream& out, const PAIR& p) {  
7.   return out << p.first << "\t" << p.second;  
8. }  
9. int main() {  
10.   map<string, int, greater<string> > name_score_map;  
11.   name_score_map["LiMin"] = 90;   
12.   name_score_map["ZiLinMi"] = 79;   
13.   name_score_map["BoB"] = 92;   
14.   name_score_map.insert(make_pair("Bing",99));  
15.   name_score_map.insert(make_pair("Albert",86));  
16.   for (map<string, int>::iterator iter = name_score_map.begin();  
17.        iter != name_score_map.end();  
18.        ++iter) {  
19.     cout << *iter << endl;  
20.   }  
21.   return 0;  
22. }  

【執行結果】

現在知道如何為map指定Compare類了，如果我們想自己寫一個compare的類，讓map按照我們想要的順序來儲存，比如，按照學生姓名的長短排序進行儲存，那該怎麼做呢？

其實很簡單，只要我們自己寫一個函式物件，實現想要的邏輯，定義map的時候把Compare指定為我們自己編寫的這個就ok啦。

1. struct CmpByKeyLength {  
2.   bool operator()(const string& k1, const string& k2) {  
3.     return k1.length() < k2.length();  
4.   }  
5. };  

是不是很簡單！這裡我們不用把它定義為模板，直接指定它的引數為string型別就可以了。

【參考程式碼】

1. int main() {  
2.   map<string, int, CmpByKeyLength> name_score_map;  
3.   name_score_map["LiMin"] = 90;   
4.   name_score_map["ZiLinMi"] = 79;   
5.   name_score_map["BoB"] = 92;   
6.   name_score_map.insert(make_pair("Bing",99));  
7.   name_score_map.insert(make_pair("Albert",86));  
8.   for (map<string, int>::iterator iter = name_score_map.begin();  
9.        iter != name_score_map.end();  
10.        ++iter) {  
11.     cout << *iter << endl;  
12.   }  
13.   return 0;  
14. }  

【執行結果】

二、C++ STL中Map的按Value排序

        在第一部分中，我們藉助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，具體定義如下：

1. template <class T1, class T2> struct pair  
2. {  
3.   typedef T1 first_type;  
4.   typedef T2 second_type;  
5.   T1 first;  
6.   T2 second;  
7.   pair() : first(T1()), second(T2()) {}  
8.   pair(const T1& x, const T2& y) : first(x), second(y) {}  
9.   template <class U, class V>  
10.     pair (const pair<U,V> &p) : first(p.first), second(p.second) { }  
11. }  

在<utility>標頭檔案中，還為pair過載了 < 運算子， 具體實現如下： 

1. template<class _T1, class _T2>  
2.   inlinebool
3.   operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)  
4.   { return __x.first < __y.first  
5.            || (!(__y.first < __x.first) && __x.second < __y.second); }  

1. __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已經過載了<符，而且我們不能修改其實現，又不能在外部重複實現過載<符。

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

那麼我們如何實現對pair按value進行比較呢？ 第一種：是最原始的方法，寫一個比較函式；  第二種：剛才用到了，寫一個函式物件。這兩種方式實現起來都比較簡單。

1. typedef pair<string, int> PAIR;  
2. bool cmp_by_value(const PAIR& lhs, const PAIR& rhs) {  
3.   return lhs.second < rhs.second;  
4. }  
5. struct CmpByValue {  
6.   bool operator()(const PAIR& lhs, const PAIR& rhs) {  
7.     return lhs.second < rhs.second;  
8.   }  
9. };  

1. template <class RandomAccessIterator>  
2.   void sort ( RandomAccessIterator first, RandomAccessIterator last );  
3. template <class RandomAccessIterator, class Compare>  
4.   void sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp );  

這裡也可以傳入一個函式指標，就是把上面說的第一種方法的函式名傳過來。（應該是存在函式指標到函式物件的轉換，或者兩者呼叫形式上是一致的，具體確切原因還不明白，希望知道的朋友給講下，先謝謝了。）

【參考程式碼】

1. int main() {  
2.   map<string, int> name_score_map;  
3.   name_score_map["LiMin"] = 90;  
4.   name_score_map["ZiLinMi"] = 79;  
5.   name_score_map["BoB"] = 92;  
6.   name_score_map.insert(make_pair("Bing",99));  
7.   name_score_map.insert(make_pair("Albert",86));  
8.  //把map中元素轉存到vector中 
9.   vector<PAIR> name_score_vec(name_score_map.begin(), name_score_map.end());  
10.   sort(name_score_vec.begin(), name_score_vec.end(), CmpByValue());  
11.  // sort(name_score_vec.begin(), name_score_vec.end(), cmp_by_value);
12.   for (int i = 0; i != name_score_vec.size(); ++i) {  
13.     cout << name_score_vec[i] << endl;  
14.   }  
15.   return 0;  
16. }  

【執行結果】