map/unordered_map用法

map/unordered_map用法

定义一个关联容器

需要分别包含头文件

#include<map>
#include<unordered_map>

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

typedef pair<const Key, T> value_type;

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

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

定义一个map/unordered_map对象

std::map<type1,type2> m;
std::unordered_map<type1,type2> u_m;

初始化

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

访问元素

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

往里面加入新的元素：

用insert插入：

//第一种
 m.insert ( std::pair<string,int>('akali',100) );
 u_m.insert ( std::pair<string,int>('ez',200) );
//第二种
std::map<string,int>::iterator it1 = m.begin();
std::map<string,int>::iterator it2 = u_m.begin();
m.insert (it1, std::pair<string,int>('bobi',300));  
u_m.insert (it2, std::pair<string,int>('karsa',400));
//第三种
 std::map<string,int> anothermap;
 anothermap.insert(m.begin(),m.find('akali'));

还可以直接赋值进去：

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

容器大小

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

常用迭代器

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

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

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

map<string,int> m;

map<string,int>::iterator it;

it = m.begin();

while(it != m.end())
{
    it->first;//访问键
    it->second;//访问值
    it ++;     
}

find，find_if

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

std::map<string,int> m({{'key1',1},{'key2',2}});

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

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

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

int main()
{
    std::map<int, std::string> 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<int, std::string>::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\n");
    else
        printf("found key:%d value:%s\n", it->first, it->second.c_str());
    std::cin.get();
    return 0;
}

其他

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//左闭右开

swap:

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

#include <iostream>
#include <map>

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

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

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

  foo.swap(bar);

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

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

  return 0;
}

/*输出：
foo contains:
a => 11
b => 22
c => 33
bar contains:
x => 100
y => 200
*/

clear:

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

// map::clear
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

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

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

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

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

  return 0;
}

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

*/

count:

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

// map::count
#include <iostream>
#include <map>

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

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

    for (c = 'a'; c<'h'; c++)
    {
        std::cout << c<<" 数量： "<<mymap.count(c) << std::endl;
    }
    std::cin.get();
    return 0;
}

/*输出：
a 数量： 1
b 数量： 0
c 数量： 1
d 数量： 0
e 数量： 0
f 数量： 1
g 数量： 0
*/

map与unordered_map的区别

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

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