關於map的定義：

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

第一個template引數被當做元素的key,第二個template引數被當作元素的value。Map的元素型別Key和T，必須滿足以下兩個條件：
１.key/value必須具備assignable(可賦值的)和copyable(可複製的)性質。
２.對排序準則而言，key必須是comparable（可比較的）。
第三個template引數可有可無，用它來定義排序準則。這個排序準則必須定義為strict weak ordering。元素的次序由它們的key決定，和value無關。排序準則也可以用來檢查相等性：如果兩個元素的key彼此的都不小於對方，則兩個元素被視為相等。如果使用未傳入特定排序準則，就使用預設的less排序準則——以operator<來進行比較。

所謂“排序準則”，必須定義strict weak ordering，其意義如下：
１.必須是“反對稱性的”。
２.必須是“可傳遞的”。
３.必須是“非自反的”。

按照定義的要求：
我們有兩種方法以自定義型別當key：
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. }

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. ｝