map unsorted_map

unordered_map：
使用hash表存储，内部无序
map：
有序性，这是map结构最大的优点空间
占用率高，因为map内部实现了红黑树，虽然提高了运行效率
multimap：
允许有键重复，有序
unordered_multimap:
允许有键重复，无序

作者：臭屁淇
来源：CSDN
原文：https://blog.csdn.net/qq_21567767/article/details/81709452
版权声明：本文为博主原创文章，转载请附上博文链接！

#include <map> 
#include<unordered_map>

1.定义一个map对象

std::map<key_type,value_type> m;
std::unordered_map<key_type,value_type> u_m;

2.初始化

//定义同时初始化
sunordered_map<string, size_t> people {{"Jan",44}, {"Jim", 33}, {"Joe", 99}}; 
//

3往里面加入新的元素

//第一种
 m.insert ( pair<string,int>('akali',100) );
 u_m.insert ( pair<string,int>('ez',200) );
 //make_pair():无需写出型别， 就可以生成一个pair对象 
 //相当于
  m.insert ( make_pair('akali',100) );
 u_m.insert ( make_pair('ez',200) );
//第二种
map<string,int>::iterator it1 = m.begin();
map<string,int>::iterator it2 = u_m.begin();
m.insert (it1, pair<string,int>('bobi',300));  
u_m.insert (it2, pair<string,int>('karsa',400));
//第三种
map<string,int> anothermap;
 anothermap.insert(m.begin(),m.find('akali'));
// 第四种,直接赋值,map中可以覆盖原来的关键字
 m['aruma']=1;
u_m['qiqi']=38;

4容器大小

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

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

m.begin()//
m.end()//这个end()返回的是最后一个元素的下一个地址
//遍历
map<string,int> m;
map<string,int>::iterator it;
it = m.begin();
while(it != m.end())
{
    it->first;//访问键
    it->second;//访问值
    it ++;     //    
}

6find，find_if
find(find_key):如果找到具有指定键的元素，则为元素的迭代器，否则为map :: 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;
}

7 erase

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

8 first,scond


unordered_map<Key,T>::iterator it;
(*it).first;             // the key value (of type Key)
it->first
(*it).second;            // the mapped value (of type T)
it->second;
(*it);                   // the "element value" (of type pair<const Key,T>)

猜你喜欢