STL之容器map、multimap、unordered_C

map和multimap

1. 定义和初始化

2. 插入数据元素 *** 作

3. 赋值 *** 作

4. 大小 *** 作

5. 查找 *** 作

6. 删除 *** 作

7. 通过operator=修改元素

unorder_map 和 unorder_multimap

1. unordered_map的头文件

2. map和unordered_map的区别

欢迎关注微信公众号 “三贝勒文子” ，每天学习C++

map和multimap

map的底层实现原理是红黑树，使用容器map和multimap需要添加的头文件：

# include

容器map和multimap的 *** 作都一样，唯一的区别就是multimap中的数据元素可以重复。

1. 定义和初始化

// map mapTT;        // map默认构造函数
// map(const map& map);     // 拷贝构造函数

2. 插入数据元素 *** 作

map.insert()：向容器插入元素，返回pair；
emplace()：在当前map容器中的指定位置处构造新键值对，其效果和插入键值对一样，但是效率高；
emplace_hint()：本质上和emplace()在map容器中构造新键值对的方式是一样的，不同之处在于，使用者必须为该方法提供一个指示键值对生成位置的迭代器，并作为该方法的第一个参数。

C++11新增的emplace()和emplace_hint(）这两个插入元素的函数接口，效率比insert()好很多。

// map.insert();          // 向容器插入元素，返回pair
// map serven_1;
 第一种插入元素的方法（通过pair的方式插入对象）
// serven_1.insert(pair(3,"文子"));
 第二种插入元素的方法 （通过pair插入对象）
// serven_1.insert(make_pair(-1,"文子"));
 第三种插入元素的方法 （通过value_type的方式插入对象）
// serven_1.insert(map);
 第四种插入元素的方法 （通过数组的方式插入值）
// serven_1[3] = "三贝勒";
// serven_1[5] = "Serven";

emplace();    // 再当前map容器中的指定位置处构造新键值对，其效果和插入键值对一样，但是效率高
emplace_hint();    // 本质上和emplace()在map容器中构造新键值对的方式是一样的，不同之处在于，使用者必须为该方法提供一个指示键值对生成位置的迭代器，并作为该方法的第一个参数



  /* map的插入元素 *** 作 */
serven_1.insert(pair(0,"Serven"));
serven_1.insert(make_pair(1,"One"));
serven_1.insert(map::value_type(2,"Two"));
serven_1.insert(map::value_type(2,"Three"));        // 相同的键值，编译能通过，但是运行后是没有添加这个的
serven_1[3] = "Four";
serven_1[4] = "Five";

map::iterator map_it1;
map_it1 = serven_1.begin();
cout<<"serven_1的数据为："<first<<", value="<second<

 
运行结果： 
 
3. 赋值 *** 作     
 map& operator=(const map& mp)：重载符号 *** 作符；
 
 swap(mp)：交换两个map容器。
 
// map& operator=(const map& mp);     // 重载符号 *** 作符
// swap(mp);                          // 交换两个map容器

/* map赋值 *** 作 */
//operator= *** 作
serven_3 = serven_1;
cout<<"serven_3的数据为："<first<<", value="<second<first<<", value="<second<
 
运行结果： 
 
4. 大小 *** 作 
 size()：返回容器中元素的数目；
 
 empty()：判断容器是否为空；
 
 max_size()：返回容器所能容纳键值对的最大个数，不同 *** 作系统返回值不一样。
 
// size();            // 返回容器中元素的数目
// empty();           // 判断容器是否为空
// max_size();        // 返回容器所能容纳键值对的最大个数，不同 *** 作系统返回值不一样

/* map的大小 *** 作 */
cout<<"serven_1的大小为："<
 
运行结果： 
 
5. 查找 *** 作 
 operator[]：map重载了[]运算符，只要知道map容器中某个键值对的键值，就可以向获取数组中元素那样，通过键直接获取对应的值；
 
 at(key)：找到map容器中key键对应的值，如果找不到就会返回异常out_of_range；
 
 find(key)：查找键为key是否存在，如果存在返回该键的元素的迭代器，不存在则返回map.end()；
 
 count(val)：返回容器中key为val的元素对组个数，对map来说，要么是0，要么是1，对multimap来说，可能是0，1，n；
 
 lower_bound(val)：返回第一个key>=val元素的迭代器；
 
 upper_bound(val)：返回第一个key>val元素的迭代器；
 
 equal_range(val)：返回容器中key与val相等的上下限的两个迭代器，注意这是返回两个迭代器。
 
// operator[];         // map重载了[]运算符，只要知道map容器中某个键值对的键值，就可以向获取数组中元素那样，通过键直接获取对应的值
// at(key);            // 找到map容器中key键对应的值，如果找不到就会返回异常out_of_range
// find(key);          // 查找键为key是否存在，如果存在返回该键的元素的迭代器，不存在则返回map.end()
// count(val);         // 返回容器中key为val的元素对组个数，对map来说，要么是0，要么是1，对multimap来说，可能是0,1，n
// lower_bound(val);   // 返回第一个key>=val元素的迭代器
// upper_bound(val);   // 返回第一个key>val元素的迭代器
// equal_range(val);   // 返回容器中key与val相等的上下限的两个迭代器

/* map的查找 *** 作*/

map serven_str;
serven_str.insert(pair("one","Ming"));
serven_str.insert(pair("two","hong"));
serven_str.insert(pair("three","fang"));
serven_str.insert(make_pair("four","cheng"));
serven_str.insert(map::value_type("five","Ming"));
serven_str.insert(map::value_type("four","wen"));
  
multimap multi_serven_str;
multi_serven_str.insert(pair("one","Ming"));
multi_serven_str.insert(pair("two","hong"));
multi_serven_str.insert(pair("three","fang"));
multi_serven_str.insert(make_pair("four","cheng"));
multi_serven_str.insert(map::value_type("five","Ming"));
multi_serven_str.insert(map::value_type("four","wen"));

cout<<"serven_str的数据为："<::iterator map_it_str;
map_it_str = serven_str.begin();
while(map_it_str != serven_str.end()){
  cout<<"key = "<first<<", value="<second<::iterator unmap_it_str;
unmap_it_str = multi_serven_str.begin();
while(unmap_it_str != multi_serven_str.end()){
  cout<<"key = "<first<<", value="<second<first<<", serven_str的第三个元素的value = "<second<first<<", 值value = "<second<first<<", 值value = "<second<first<<", 值value = "<second<::iterator, map::iterator> Two_it;
Two_it = serven_str.equal_range("four");
for(map::iterator it = Two_it.first; it !=Two_it.second; it++){
  cout << it->first << " => " << it->second << '\n';
} 
运行结果： 
 
6. 删除 *** 作 
 clear()：删除所有元素；
 
 erase(pos)：删除pos迭代器所指的元素，返回下一元素的迭代器；
 
 erase(begin, end)：删除区间[begin, end)的所有元素，返回下一元素的迭代器；
 
 erase(val)：删除容器中key为val的元素对组。
 
  
 
clear();                // 删除所有元素
erase(pos);             // 删除pos迭代器所指的元素，返回下一元素的迭代器
erase(begin, end);      // 删除区间[begin, end)的所有元素，返回下一元素的迭代器
erase(val);             // 删除容器中key为val的元素对组


/* map的删除 *** 作 */
cout<<"serven_2的数据为："<欢迎分享，转载请注明来源：内存溢出
原文地址:https://www.54852.com/langs/734047.html

STL之容器map、multimap、unordered

`发表评论`

`评论列表（0条）`