map和unordered_map的用法和区别

用法

定义一个关联容器

需要分别包含头文件

#include
#include
1
2

map/unordered_map是一个关联容器，它按照特定顺序存储由键值和映射值的组合形成的元素；
在映射中，键值通常用于排序和唯一标识元素，而映射值存储与此键关联的内容。键和映射值的类型可能不同，并在成员类型value_type中组合在一起，这是一种结合两者的对类型：

typedef pair value_type;
1

map容器通常比unordered_map容器慢，以便通过键访问单个元素，但它们允许根据子集的顺序直接迭代子集。在该映射值地图可以直接通过使用其相应的键来访问括号运算符（（操作符[] ）。映射通常如实施二叉搜索树。

key:每个元素都由其键值唯一标识。
T:这个键对应的值
和python中的字典差不多意思。

定义一个map/unordered_map对象

std::map m;
std::unordered_map u_m;
1
2

初始化

std::map m({{'key1',1},{'key2',2}});
std::unordered_map u_m({{'key1',1},{'key2',2}});
也可以先定义完再赋值
1
2
3

访问元素

用操作符[]访问，如：m[‘key1’]；访问的得到的是key1对应的value。

往里面加入新的元素：

用insert插入：

//第一种
 m.insert ( std::pair('akali',100) );
 u_m.insert ( std::pair('ez',200) );
//第二种
std::map::iterator it1 = m.begin();
std::map::iterator it2 = u_m.begin();
m.insert (it1, std::pair('bobi',300));  
u_m.insert (it2, std::pair('karsa',400));
//第三种
 std::map anothermap;
 anothermap.insert(m.begin(),m.find('akali'));
1
2
3
4
5
6
7
8
9
10
11

还可以直接赋值进去：

m['aruma']=1;
u_m['qiqi']=38;
1
2

容器大小

m.max_size()//返回容器可以作为内容保存 的最大元素数。
m.size()//返回容器中的元素数量。
m.empty()//返回bool值，判断是否为空。
1
2
3

常用迭代器

begin():容器中第一个元素的迭代器。如果map对象是const限定的，则该函数返回一个const_iterator。否则，它返回一个迭代器。迭代器是一种泛型指针。可以用这个迭代器来访问对象的键和值。

m.begin()//
m.end()//这个end()返回的是最后一个元素的下一个地址
1
2

可以用这些迭代器来遍历整个map对象：

map m;

map::iterator it;

it = m.begin();

while(it != m.end())
{
    it->first;//访问键
    it->second;//访问值
    it ++;     //    
}
1
2
3
4
5
6
7
8
9
10
11
12

find，find_if

find(find_key):如果找到具有指定键的元素，则为元素的迭代器，否则为map :: end。就是说如果这个map里含有find_key这个键的话就返回它对应的迭代器，否则返回end()；这个可以用来判断这个值是否存在于其中。

std::map m({{'key1',1},{'key2',2}});

if(m.find('key1')==m.end()){
    std::cout<<"不存在"<

find_if：它不是map中的方法，根据指定的pred运算条件（以仿函数表示），循环查找[first,last)内的所有元素，找出第一个令pred运算结果true者。如果找到就返回一个InputIterator指向该元素，否则就返回迭代器last。

#include
#include
#include 
#include  //std::find_if
//map的value_type是std::pair类型
class map_value_finder
{
public:
    map_value_finder(const std::string &cmp_string) :m_s_cmp_string(cmp_string) {}
    bool operator ()(const std::map::value_type &pair)
    {
        return pair.second == m_s_cmp_string;
    }
private:
    const std::string &m_s_cmp_string;
};

int main()
{
    std::map my_map;
    my_map.insert(std::make_pair(10, "china"));
    my_map.insert(std::make_pair(20, "usa"));
    my_map.insert(std::make_pair(30, "english"));
    my_map.insert(std::make_pair(40, "hongkong"));

    std::map::iterator it = my_map.end();
    it = std::find_if(my_map.begin(), my_map.end(), map_value_finder("English"));
    if (it == my_map.end())
        printf("not found
");
    else
        printf("found key:%d value:%s
", it->first, it->second.c_str());
    std::cin.get();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

其他

erase：

从地图容器中移除单个元素或一系列元素（[first，last））。这有效地减少了容器的大小，删除了被删除的元素数量。该函数返回已擦除的元素数。

  it=m.find('b');
  m.erase (it);                   // erasing by iterator

  m.erase ('c');                  // erasing by key

  it=m.find ('e');
  m.erase ( it, m.end() );    // erasing by range//左闭右开
1
2
3
4
5
6
7

swap:

交换两个同类型容器的内容，尺寸可以不同。

#include 
#include 

int main ()
{
  std::map foo,bar;

  foo['x']=100;
  foo['y']=200;

  bar['a']=11;
  bar['b']=22;
  bar['c']=33;

  foo.swap(bar);

  std::cout << "foo contains:
";
  for (std::map::iterator it=foo.begin(); it!=foo.end(); ++it)
    std::cout << it->first << " => " << it->second << '
';

  std::cout << "bar contains:
";
  for (std::map::iterator it=bar.begin(); it!=bar.end(); ++it)
    std::cout << it->first << " => " << it->second << '
';

  return 0;
}

/*输出：
foo contains:
a => 11
b => 22
c => 33
bar contains:
x => 100
y => 200
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

clear:

删除所有元素，使容器的大小为0。

// map::clear
#include 
#include 

int main ()
{
  std::map mymap;

  mymap['x']=100;
  mymap['y']=200;
  mymap['z']=300;

  std::cout << "mymap contains:
";
  for (std::map::iterator it=mymap.begin(); it!=mymap.end(); ++it)
    std::cout << it->first << " => " << it->second << '
';

  mymap.clear();
  mymap['a']=1101;
  mymap['b']=2202;

  std::cout << "mymap contains:
";
  for (std::map::iterator it=mymap.begin(); it!=mymap.end(); ++it)
    std::cout << it->first << " => " << it->second << '
';

  return 0;
}

/*
mymap contains:
x => 100
y => 200
z => 300
mymap contains:
a => 1101
b => 2202

*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

count:

计数，但是map中本身key就是唯一的，所以包含这返回1，不包含则返回0。

// map::count
#include 
#include 

int main()
{
    std::map mymap;
    char c;

    mymap['a'] = 101;
    mymap['c'] = 202;
    mymap['f'] = 303;
    mymap['f'] = 304;

    for (c = 'a'; c<'h'; c++)
    {
        std::cout << c<<" 数量： "<

map与unordered_map的区别

map： map内部实现了一个红黑树，该结构具有自动排序的功能，因此map内部的所有元素都是有序的，红黑树的每一个节点都代表着map的一个元素，因此，对于map进行的查找，删除，添加等一系列的操作都相当于是对红黑树进行这样的操作，故红黑树的效率决定了map的效率。
unordered_map: unordered_map内部实现了一个哈希表，因此其元素的排列顺序是杂乱的，无序的

上面那些方法都是一样的用法。