map以自定义类型当Key

 

 

关于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>
5. using namespace std;
7. class test
8. {
9. public:
11. bool operator<(const test& a)const;
12. //private:
13. int nA;
14. int nB;
15. };
17. bool test::operator<(const test& a)const
18. {
19. if(this->nA < a.nA)
20. return true;
21. else
22.     {
23. if(this->nA == a.nA && this->nB < a.nB)
24. return true;
25. else
26. return false;
27.     }
28. }
30. int main()
31. {
32.     map<test, string> myTestDemo;
33.     test tA;
34.     tA.nA = 1;
35.     tA.nB = 1;
36.     test tB;
37.     tB.nA = 1;
38.     tB.nB = 2;
39.     myTestDemo.insert(pair<test, string>(tA, "first!"));
40.     myTestDemo.insert(pair<test, string>(tB, "second!"));
42.     map<test, string>::iterator myItr = myTestDemo.begin();
43.     cout << "itr begin test nA:" << myItr->first.nA << endl;
44.     cout << "itr begin test nB:" << myItr->first.nB << endl;
45.     cout << "itr begin test string:" << myItr->second << endl;
46. return 1;
47. }

2. 不使用map的第三个参数为默认仿函数less<key>，自己编写一个比较仿函数。

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