map的键使用自定义结构体

背景:

 

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

特别注意: operator < 函数的详细内容,一定要满足strict weakly ordering,不能单纯的返回false或true

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

 

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

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

注: 以上所述同样适用于multimap

另,只要有了上述实现,map也可以使用find函数了,不需要重载==