背景:

map的定義

template<class Key, class T, class Pred = less<Key>, class A = allocator<T> >

可見,map的定義是一個模板類,模板引數為Key,T,Pred,A,各引數的含義如下:

Key---------鍵

T------------值

Pred--------map用於比較鍵的類,這個類必須過載()操作符,在其中定義比較操作..(雖然比較怪,不是過載大於小於號,但的確是這樣定義的)

A------------記憶體分配

注:由於map是採用了紅黑樹,而紅黑樹在操作節點時都需要依賴於比較節點間的大小,所以鍵採用自定義結構體的條件就是得讓系統可以對其進行比較.可以通過兩種方法提供這種功能:

1. 為結構體過載<操作符

2. 不需要為結構體過載<操作符.但需要提供一個Pred類,且該類提供了operator()過載.實際上通過class Pred = less<Key>可以看出,map預設使用系統提供的less類.

以下為兩種方案的例子:

1.為自定義型別過載operator<，map的第三個引數為預設仿函式less<key>。
例子：

1. #include <iostream>
2. #include <map>
3. #include <string>
4. using   namespace  std;
5. class  test
6. {
7. public :
8.      bool  operator<( const  test& a) const ;
9. //private:
10.      int  nA;
11.      int  nB;
12. };
13. bool  test::operator<( const  test& a) const
14. {
15.      if ( this ->nA < a.nA)
16.          return   true ;
17.      else
18.     {
19.          if ( this ->nA == a.nA &&  this
    ->nB < a.nB)
20.              return   true ;
21.          else
22.              return   false ;
23.     }
24. }
25. int  main()
26. {
27.     map<test, string> myTestDemo;
28.     test tA;
29.     tA.nA = 1;
30.     tA.nB = 1;
31.     test tB;
32.     tB.nA = 1;
33.     tB.nB = 2;
34.     myTestDemo.insert(pair<test, string>(tA,  "first!" ));
35.     myTestDemo.insert(pair<test, string>(tB,  "second!" ));
36.     map<test, string>::iterator myItr = myTestDemo.begin();
37.     cout <<  "itr begin test nA:"  << myItr->first.nA << endl;
38.     cout <<  "itr begin test nB:"  << myItr->first.nB << endl;
39.     cout <<  "itr begin test string:"  << myItr->second << endl;
40.      return  1;
41. }

特別注意: operator < 函式的詳細內容,一定要滿足strict weakly ordering,不能單純的返回false或true

可以參考:http://www.softwelt.com/Know/KnowDetail-113762.html

2.不使用map的第三個引數為預設仿函式less<key>，自己編寫一個比較仿函式。

1. #include <iostream>
2. #include <map>
3. using   namespace  std;
4. struct  keyOfMap
5. {
6.      int  firstOfKey;
7.      int  secondOfKey;
8. };
9. struct  myMapFunctor
10. {
11.      bool  operator()( const  keyOfMap& k1,  const  keyOfMap& k2)  const
12.     {
13.          if (k1.firstOfKey < k2.firstOfKey)
14.              return   true ;
15.          else
16.              return   false ;
17.     }
18. };
19. int  main()
20. {
21.     map<keyOfMap, string, myMapFunctor> test;
22.     keyOfMap temp1;
23.     keyOfMap temp2;
24.     temp1.firstOfKey = 1;
25.     temp1.secondOfKey = 1;
26.     temp2.firstOfKey = 2;
27.     temp2.secondOfKey = 2;
28.     test.insert(make_pair<keyOfMap, string>(temp1,  "first" ));
29.     test.insert(make_pair<keyOfMap, string>(temp2,  "second" ));
30.     map<keyOfMap, string, myMapFunctor>::iterator begin = test.begin();
31.     cout << begin->first.firstOfKey << begin->first.secondOfKey << begin->second << endl;
32.      return  1;
33. ｝