STL map and boost unordered_map

STL map and boost unordered_map

Today, we can see boost: unordered_map. The difference between it and STL: map is that STL: Map judges whether the elements are the same Based on operator <comparison, and compares the element size, select a suitable position and insert it to the tree. Therefore, if the map is traversed (in the middle order), the output result is ordered. The order is sorted by the operator <defined size.

Boost: unordered_map is the hash value of the computing element. It determines whether the elements are the same Based on the hash value. Therefore, the unordered_map traversal results are unordered.

 

The difference in usage is that the key of STL: Map needs to define operator <. While boost: unordered_map needs to define the hash_value function and reload operator =. Do not worry about built-in types, such as string. For custom type keys, you need to reload operator <or hash_value () by yourself.

 

Finally, it is recommended that unordered_map be used when no sorting of results is required.

 

Actually, STL: Map corresponds to treemap in Java, while boost: unordered_map corresponds to hashmap in Java.

 

STL: Map

 

 

1. # Include <string>
2. # Include <iostream>
3. # Include <map>
5. Using namespace STD;
7. Struct person
8. {
9. String name;
10. Int age;
12. Person (string name, int age)
13. {
14. This-> name = Name;
15. This-> age = age;
16. }
18. Bool operator <(const person & P) const
19. {
20. Return this-> age <p. Age;
21. }
22. };
24. Map <person, int> m;
25. Int main ()
26. {
27. Person p1 ("tom1", 20 );
28. Person P2 ("tom2", 22 );
29. Person P3 ("tom3", 22 );
30. Person P4 ("tom4", 23 );
31. Person P5 ("tom5", 24 );
32. M. insert (make_pair (P3, 100 ));
33. M. insert (mak_pair (P4, 100 ));
34. M. insert (make_pair (p53, 100 ));
35. M. insert (make_pair (P1, 100 ));
36. M. insert (make_pair (P2, 100 ));
38. For (Map <person, int >:: iterator iter = M. Begin (); iter! = M. End (); ITER ++)
39. {
40. Cout <ITER-> first. Name <"\ t" <ITER-> first. age <Endl;
41. }
43. Return 0;
44. }

 

Output:

Tom1 20
Tom3 22
Tom4 23
Tom5 24

 

Operator <must be defined as Const. Because the operator <function called in the internal implementation of map seems to be const.

Because operator <compares only age, because tom2 and tom3 have the same age, the final result is only tom3, but not tom2.

 

Boost: unordered_map

 

1. # Include <string>
2. # Include <iostream>
4. # Include <boost/unordered_map.hpp>
6. Using namespace STD;
8. Struct person
9. {
10. String name;
11. Int age;
13. Person (string name, int age)
14. {
15. This-> name = Name;
16. This-> age = age;
17. }
19. Bool operator = (const person & P) const
20. {
21. Return name = P. Name & age = P. Age;
22. }
23. };
25. Size_t hash_value (const person & P)
26. {
27. Size_t seed = 0;
28. Boost: hash_combine (seed, boost: hash_value (P. Name ));
29. Boost: hash_combine (seed, boost: hash_value (P. Age ));
30. Return seed;
31. }
33. Int main ()
34. {
35. Typedef boost: unordered_map <person, int> umap;
36. Umap m;
37. Person p1 ("tom1", 20 );
38. Person P2 ("tom2", 22 );
39. Person P3 ("tom3", 22 );
40. Person P4 ("tom4", 23 );
41. Person P5 ("tom5", 24 );
42. M. insert (umap: value_type (P3, 100 ));
43. M. insert (umap: value_type (P4, 100 ));
44. M. insert (umap: value_type (p53, 100 ));
45. M. insert (umap: value_type (P1, 100 ));
46. M. insert (umap: value_type (P2, 100 ));
48. For (umap: iterator iter = M. Begin (); iter! = M. End (); ITER ++)
49. {
50. Cout <ITER-> first. Name <"\ t" <ITER-> first. age <Endl;
51. }
53. Return 0;
54. }

Output

 

Tom1 20
Tom5 24
Tom4 23
Tom2 22
Tom3 22

 

You must customize operator = and hash_value. The heavy-load operator = is because if the hash_value values of the two elements are the same, it cannot be determined that the two elements are the same. Operator = must be called. Of course, if the hash_value value is different, you do not need to call operator =.