map与unordered_map

 Map是c++的一个标准容器，她提供了很好一对一的关系，在一些程序中建立一个map可以起到事半功倍的效果，总结了一些map基本简单实用的操作！
1. map最基本的构造函数；
   map<string , int >mapstring;         map<int ,string >mapint;
   map<sring, char>mapstring;         map< char ,string>mapchar;
   map<char ,int>mapchar;            map<int ,char >mapint；

2. map添加数据；

   map<int ,string> maplive;  
   1.maplive.insert(pair<int,string>(102,"aclive"));
   2.maplive.insert(map<int,string>::value_type(321,"hai"));
   3, maplive[112]="April";//map中最简单最常用的插入添加！
3，map中元素的查找：

   find()函数返回一个迭代器指向键值为key的元素，如果没找到就返回指向map尾部的迭代器。        

   map<int ,string >::iterator l_it;; 
   l_it=maplive.find(112);
   if(l_it==maplive.end())
                cout<<"we do not find 112"<<endl;
   else cout<<"wo find 112"<<endl;
4,map中元素的删除：
   如果删除112；
   map<int ,string >::iterator l_it;;
   l_it=maplive.find(112);
   if(l_it==maplive.end())
        cout<<"we do not find 112"<<endl;
   else  maplive.erase(l_it);  //delete 112;
5,map中 swap的用法：
  Map中的swap不是一个容器中的元素交换，而是两个容器交换；
  For example：
  #include <map>
  #include <iostream>

  using namespace std;

  int main( )
  {
      map <int, int> m1, m2, m3;
      map <int, int>::iterator m1_Iter;

      m1.insert ( pair <int, int>  ( 1, 10 ) );
      m1.insert ( pair <int, int>  ( 2, 20 ) );
      m1.insert ( pair <int, int>  ( 3, 30 ) );
      m2.insert ( pair <int, int>  ( 10, 100 ) );
      m2.insert ( pair <int, int>  ( 20, 200 ) );
      m3.insert ( pair <int, int>  ( 30, 300 ) );

   cout << "The original map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter->second;
      cout   << "." << endl;

   // This is the member function version of swap
   //m2 is said to be the argument map; m1 the target map
   m1.swap( m2 );

   cout << "After swapping with m2, map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
      cout  << "." << endl;
   cout << "After swapping with m2, map m2 is:";
   for ( m1_Iter = m2.begin( ); m1_Iter != m2.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
      cout  << "." << endl;
   // This is the specialized template version of swap
   swap( m1, m3 );

   cout << "After swapping with m3, map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
      cout   << "." << endl;
}

6.map的sort问题：
  Map中的元素是自动按key升序排序,所以不能对map用sort函数：
  For example：
  #include <map>
  #include <iostream>

  using namespace std;

 int main( )
 {
   map <int, int> m1;
   map <int, int>::iterator m1_Iter;

   m1.insert ( pair <int, int>  ( 1, 20 ) );
   m1.insert ( pair <int, int>  ( 4, 40 ) );
   m1.insert ( pair <int, int>  ( 3, 60 ) );
   m1.insert ( pair <int, int>  ( 2, 50 ) );
   m1.insert ( pair <int, int>  ( 6, 40 ) );
   m1.insert ( pair <int, int>  ( 7, 30 ) );

   cout << "The original map m1 is:"<<endl;
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout <<  m1_Iter->first<<" "<<m1_Iter->second<<endl;
  
}
  The original map m1 is:
  1 20
  2 50
  3 60
  4 40
  6 40
  7 30
  请按任意键继续. . .

7，   map的基本操作函数：
      C++ Maps是一种关联式容器，包含“关键字/值”对
      begin()          返回指向map头部的迭代器
      clear(）         删除所有元素
      count()          返回指定元素出现的次数
      empty()          如果map为空则返回true
      end()            返回指向map末尾的迭代器
      equal_range()    返回特殊条目的迭代器对
      erase()          删除一个元素
      find()           查找一个元素
      get_allocator()  返回map的配置器
      insert()         插入元素
      key_comp()       返回比较元素key的函数
      lower_bound()    返回键值>=给定元素的第一个位置
      max_size()       返回可以容纳的最大元素个数
      rbegin()         返回一个指向map尾部的逆向迭代器
      rend()           返回一个指向map头部的逆向迭代器
      size()           返回map中元素的个数
      swap()            交换两个map
      upper_bound()     返回键值>给定元素的第一个位置
      value_comp()      返回比较元素value的函数

#include <string>
#include <iostream>
#include <unordered_map>
using namespace std;
class humanInfo
{
public:
humanInfo();
humanInfo(string personName, u16 personage) :name(personName), age(personage) {}
humanInfo(string personName) :name(personName) {}
humanInfo(u16 personage) : age(personage) {}
~humanInfo();
string getname(){ return name; }
int getage(){ return age; }
private:
string name;
//string sex;
int age;
//s32 height;
//s32 weight;
};

typedef unordered_map<string, humanInfo *> maplive;//使用类作为内容，string为关键字。
typedef unordered_map<string, humanInfo *>::iterator mapIter;//迭代，用指针结构查看。
typedef unordered_map<string, humanInfo *>::const_iterator mapconst;//
int _tmain(int argc, _TCHAR* argv[])
{
maplive m1;
mapIter miter;
char temp;
m1.insert(pair<string, humanInfo *>("xiao5", new humanInfo("xiaoming", 10)));//初始化，pair配对的意思，考虑泄露（new）
m1.insert(pair<string, humanInfo *>("xiao1", new humanInfo("xiaohua", 6)));//这类初始化，如果存在，保持之前的内容
m1.insert(pair<string, humanInfo *>("xiao2", new humanInfo("xiaocao", 7)));
m1.insert(pair<string, humanInfo *>("xiao3", new humanInfo("xiaohuang", 1)));
m1.insert(pair<string, humanInfo *>("xiao4", new humanInfo("xiaozhang", 20)));
m1["xiao6"] = new humanInfo("xiaoli", 20);//也可以作为初始化，也可以进行对应修改。

//m1["xiao3"] = new humanInfo("xiaoli", 20);
cout << "The original map m1 is:" << m1.size() << endl;
for (miter = m1.begin(); miter != m1.end(); miter++)//轮询
cout << miter->first << " " << ((humanInfo *)(miter->second))->getname() << " " << ((humanInfo *)(miter->second))->getage() << endl;

miter = m1.find("xiao3");

if (miter != m1.end())
{

miter1 = miter;
miter++;
cout << "find:" << miter1->first << " " << miter1->second << endl;
m1.erase(miter1);//如果删除了miter1，再miter1++会死掉。
}



cout << "The original map m1 is1:" << endl;
for (miter = m1.begin(); miter != m1.end(); miter++)
cout << miter->first << " " << ((humanInfo *)(miter->second))->getname() << " " << ((humanInfo *)(miter->second))->getage() << endl;


cin >> temp;
temp = 1;
return 0;
}

The original map m1 is:6
xiao5 xiaoming 10
xiao1 xiaohua 6
xiao2 xiaocao 7
xiao3 xiaohuang 1
xiao4 xiaozhang 20
xiao6 xiaoli 20
find:xiao3 007C0900
The original map m1 is1:
xiao5 xiaoming 10
xiao1 xiaohua 6
xiao2 xiaocao 7
xiao4 xiaozhang 20
xiao6 xiaoli 20

测试程序说明：

先准备好n个字符串随机的MD5字符串做为key，然后分别对3个容器进行插入、遍历、查找、删除操作。

例如，n=100的时候，插入是指插入100个随机MD5 key；遍历是指对容器遍历一次；查找是指分别对这个100个随机的MD5 key做查找操作（即查找100次）；删除是指挨个删除这个100个随机MD5 key。

测试数据如下表：

插入，单位us1001K10K100K1M10Mstd::map241283335888381214443908862233380std::ext/hash_map97166716466146025178844618512639std::tr1::unordered_map777728052530946583127429297

遍历，单位us1001K10K100K1M10Mstd::map1176842116031557001771906std::ext/hash_map474304218398804703444781575std::tr1::unordered_map112121

查找，单位us1001K10K100K1M10Mstd::map156211130456258709410026059064394std::ext/hash_map777748056569746602317705527std::tr1::unordered_map777728051544566595377600263

删除，单位us1001K10K100K1M10Mstd::map291364149584472414667589792491113std::ext/hash_map8986990688652496476710372650std::tr1::unordered_map494804879330873950984369617

结论：

1. std::tr1::unordered_map 与 std::ext/hash_map 

     任何情况下，如果要在这两个容器之间选择的话，我们毫不犹豫应该选择 unordered_map。因为他的性能在上述4中操作中均优于 hash_map，甚至可以说远远优于 hash_map。

2. std::tr1::unordered_map 与 std::map 

     map的性能总体来说是最差的。但是，当我们需要一个有序的关联容器的时候，我们必须选择std::map，因为 unordered_map 内部元素不是有序的，这一点从名字都可以看出来。除此之外都应该选择 unordered_map 。

3. 上述测试中，unordered_map 的遍历性能几乎是常数级别的，与常识不太相符，需要再研究研究。

附录：贴上源代码

说明：与测试程序稍有区别，这里的源码里没有MD5相关的代码以确保其他人能比较方便的直接拿去编译运行。

如有错误还请跟帖指出，非常感谢。

1. #include <iostream>
   
2. #include <string>
   
3. #include <sstream>
   
4. #include <list>
   
5. #include <map>
   
6. #include <sys/time.h>
   
7. #include <ext/hash_map>
   
8. #include <tr1/unordered_map>
   
9. 
   
10. namespace zl
    
11. { //{{{
    
12.     struct equal_to
    
13.     {
    
14.         bool operator()(const char* s1, const char* s2) const
    
15.         {
    
16.             return strcmp(s1, s2) == 0;
    
17.         }
    
18.     };
    
19.  
    
20.     struct hash_string
    
21.         : public std::unary_function<std::string, std::size_t>
    
22.         {
    
23.             std::size_t
    
24.                 operator()(const std::string& __s) const
    
25. #ifdef __linux__
    
26.                 { return std::tr1::Fnv_hash<>::hash(__s.data(), __s.length()); }
    
27. #else
    
28.                 { return std::tr1::_Fnv_hash<>::hash(__s.data(), __s.length()); }
    
29. #endif
    
30.         };
    
31. 
    
32.     
    
33.     struct hash_charptr
    
34.         : public std::unary_function<const char*, std::size_t>
    
35.         {
    
36.             std::size_t
    
37.                 operator()(const char* __s) const
    
38. #ifdef __linux__
    
39.                 { return std::tr1::Fnv_hash<>::hash(__s, strlen(__s)); }
    
40. #else
    
41.                 { return std::tr1::_Fnv_hash<>::hash(__s, strlen(__s)); }
    
42. #endif
    
43.         };
    
44. }//}}}
    
45. 
    
46. typedef std::list<std::string> string_list;
    
47. typedef std::map<std::string, int> string_map;
    
48. typedef __gnu_cxx::hash_map<std::string, int, zl::hash_string> string_hash_map;
    
49. typedef std::tr1::unordered_map<std::string, int> string_unordered_map;
    
50. 
    
51. void fill_list(string_list& slist, size_t count);
    
52. uint64_t current_usec();
    
53. 
    
54. int main( int argc, char* argv[] )
    
55. {
    
56.     if (argc != 2 && argc != 3)
    
57.     {
    
58.         fprintf(stderr, "Usage:%s test_count rehash\n", argv[0]);
    
59.         fprintf(stderr, "For example:%s 10000 rehash\n", argv[0]);
    
60.         return -1;
    
61.     }
62. 
    
63.     size_t count = atoi(argv[1]);
    
64.     bool rehash = false;
    
65.     if (argc == 3)
    
66.     {
    
67.         rehash = true;
    
68.     }
    
69. 
    
70.     string_map smap;
    
71.     string_hash_map shash_map;
    
72.     string_unordered_map sunordered_map;
    
73. 
    
74.     if (rehash)
    
75.     {
    
76.         sunordered_map.rehash(count);
    
77.     }
    
78. 
    
79.     string_list slist;
    
80.     fill_list(slist, count);
    
81. 
    
82.     uint64_t start = 0;
    
83.     uint64_t end = 0;
    
84. 
    
85.     uint64_t map_insert_us = 0;
    
86.     uint64_t hash_map_insert_us = 0;
    
87.     uint64_t unordered_map_insert_us = 0;
    
88. 
    
89.     uint64_t map_traverse_us = 0;
    
90.     uint64_t hash_map_traverse_us = 0;
    
91.     uint64_t unordered_map_traverse_us = 0;
    
92. 
    
93.     uint64_t map_find_us = 0;
    
94.     uint64_t hash_map_find_us = 0;
    
95.     uint64_t unordered_map_find_us = 0;
    
96. 
    
97.     uint64_t map_delete_us = 0;
    
98.     uint64_t hash_map_delete_us = 0;
    
99.     uint64_t unordered_map_delete_us = 0;
    
100. 
     
101. 
     
102. 
     
103.     // Insert test
     
104.     {//{{{
     
105.         string_list::iterator it(slist.begin());
     
106.         string_list::iterator ite(slist.end());
     
107. 
     
108.         //map insert
     
109.         start = current_usec();
     
110.         for (int i = 0; it != ite; ++it, ++i)
     
111.         {
     
112.             smap[*it] = i;
     
113.         }
     
114.         end = current_usec();
     
115.         map_insert_us = end - start;
     
116. 
     
117.         //hash_map insert
     
118.         it = slist.begin();
     
119.         start = current_usec();
     
120.         for (int i = 0; it != ite; ++it, ++i)
     
121.         {
     
122.             shash_map[*it] = i;
     
123.         }
     
124.         end = current_usec();
     
125.         hash_map_insert_us = end - start;
     
126. 
     
127.         //unordered_map insert
     
128.         it = slist.begin();
     
129.         start = current_usec();
     
130.         for (int i = 0; it != ite; ++it, ++i)
     
131.         {
     
132.             shash_map[*it] = i;
     
133.         }
     
134.         end = current_usec();
     
135.         unordered_map_insert_us = end - start;
     
136.     }//}}}
     
137. 
     
138.     // Traverse test
     
139.     {//{{{
     
140.         //map traverse 
     
141.         {
     
142.             string_map::iterator it(smap.begin());
     
143.             string_map::iterator ite(smap.end());
     
144.             start = current_usec();
     
145.             for (int i = 0; it != ite; ++it)
     
146.             {
     
147.                 i++;
     
148.             }
     
149.             end = current_usec();
     
150.             map_traverse_us = end - start;
     
151.         }
     
152. 
     
153.         //hash_map traverse 
     
154.         {
     
155.             string_hash_map::iterator it(shash_map.begin());
     
156.             string_hash_map::iterator ite(shash_map.end());
     
157.             start = current_usec();
     
158.             for (int i = 0; it != ite; ++it)
     
159.             {
     
160.                 i++;
     
161.             }
     
162.             end = current_usec();
     
163.             hash_map_traverse_us = end - start;
     
164.         }
     
165. 
     
166.         //unordered_map traverse 
     
167.         {
     
168.             string_unordered_map::iterator it(sunordered_map.begin());
     
169.             string_unordered_map::iterator ite(sunordered_map.end());
     
170.             start = current_usec();
     
171.             for (int i = 0; it != ite; ++it)
     
172.             {
     
173.                 i++;
     
174.             }
     
175.             end = current_usec();
     
176.             unordered_map_traverse_us = end - start;
     
177.         }
     
178.     }//}}}
     
179. 
     
180.     // Find test
     
181.     {//{{{
     
182.         string_list::iterator it(slist.begin());
     
183.         string_list::iterator ite(slist.end());
     
184. 
     
185.         //map find
     
186.         start = current_usec();
     
187.         for (int i = 0; it != ite; ++it, ++i)
     
188.         {
     
189.             smap[*it] = i;
     
190.         }
     
191.         end = current_usec();
     
192.         map_find_us = end - start;
     
193. 
     
194.         //hash_map find
     
195.         it = slist.begin();
     
196.         start = current_usec();
     
197.         for (int i = 0; it != ite; ++it, ++i)
     
198.         {
     
199.             shash_map[*it] = i;
     
200.         }
     
201.         end = current_usec();
     
202.         hash_map_find_us = end - start;
     
203. 
     
204.         //unordered_map find
     
205.         it = slist.begin();
     
206.         start = current_usec();
     
207.         for (int i = 0; it != ite; ++it, ++i)
     
208.         {
     
209.             shash_map[*it] = i;
     
210.         }
     
211.         end = current_usec();
     
212.         unordered_map_find_us = end - start;
     
213.     }//}}}
     
214. 
     
215.     // Delete test
     
216.     {//{{{
     
217.         string_list::iterator it(slist.begin());
     
218.         string_list::iterator ite(slist.end());
     
219. 
     
220.         //map delete
     
221.         start = current_usec();
     
222.         for (int i = 0; it != ite; ++it, ++i)
     
223.         {
     
224.             smap.erase(*it);
     
225.         }
     
226.         end = current_usec();
     
227.         map_delete_us = end - start;
     
228. 
     
229.         //hash_map delete
     
230.         it = slist.begin();
     
231.         start = current_usec();
     
232.         for (int i = 0; it != ite; ++it, ++i)
     
233.         {
     
234.             shash_map.erase(*it);
     
235.         }
     
236.         end = current_usec();
     
237.         hash_map_delete_us = end - start;
     
238. 
     
239.         //unordered_map delete
     
240.         it = slist.begin();
     
241.         start = current_usec();
     
242.         for (int i = 0; it != ite; ++it, ++i)
     
243.         {
     
244.             shash_map.erase(*it);
     
245.         }
     
246.         end = current_usec();
     
247.         unordered_map_delete_us = end - start;
     
248.     }//}}}
     
249. 
     
250.     //stat output
     
251.     std::cout << " insert, count " << count << std::endl;
     
252.     std::cout << " std::map " << map_insert_us << " us\n";
     
253.     std::cout << " std::ext/hash_map " << hash_map_insert_us << " us\n";
     
254.     std::cout << "std::tr1::unordered_map " << unordered_map_insert_us << " us\n";
     
255. 
     
256.     std::cout << "\n";
     
257.     std::cout << " traverse, count " << count << std::endl;
     
258.     std::cout << " std::map " << map_traverse_us << " us\n";
     
259.     std::cout << " std::ext/hash_map " << hash_map_traverse_us << " us\n";
     
260.     std::cout << "std::tr1::unordered_map " << unordered_map_traverse_us << " us\n";
     
261. 
     
262.     std::cout << "\n";
     
263.     std::cout << " find, count " << count << std::endl;
     
264.     std::cout << " std::map " << map_find_us << " us\n";
     
265.     std::cout << " std::ext/hash_map " << hash_map_find_us << " us\n";
     
266.     std::cout << "std::tr1::unordered_map " << unordered_map_find_us << " us\n";
     
267. 
     
268.     std::cout << "\n";
     
269.     std::cout << " delete, count " << count << std::endl;
     
270.     std::cout << " std::map " << map_delete_us << " us\n";
     
271.     std::cout << " std::ext/hash_map " << hash_map_delete_us << " us\n";
     
272.     std::cout << "std::tr1::unordered_map " << unordered_map_delete_us << " us\n";
     
273. 
     
274.      
     
275.     return 0;
     
276. }
     
277. 
     
278. void fill_list(string_list& slist, size_t count)
     
279. {
     
280.     for (size_t i = 0; i < count; ++i)
     
281.     {
     
282.         std::ostringstream oss;
     
283.         oss << i;
     
284.         //slist.push_back(MD5::getHexMD5(oss.str().c_str(), oss.str().length()));
     
285.         slist.push_back(oss.str());
     
286.     }
     
287. }
     
288. 
     
289. 
     
290. uint64_t current_usec()
     
291. {
     
292.     struct timeval tv;
     
293.     gettimeofday( &tv, NULL );
     
294.     return tv.tv_sec * 1000 * 1000 + tv.tv_usec;
     
295. }