map
map以模板(泛型)方式实现，可以存储任意类型的数据，包括使用者自定义的数据类型。Map主要用于资料一对一映射(one-to-one)的情況，map內部的实现自建一颗红黑树，这颗树具有对数据自动排序的功能。(默认是从小到大，字典序排序)
map是STL的一个关联容器，它提供一对一的hash。
第一个可以称为关键字(key)，每个关键字只能在map中出现一次；
第二个可能称为该关键字的值(value)；
基本操作：
map关联容器添加元素其实是pair类型的：
pair类型是在有文件utility中定义的，pair类型包含了两个数据值，默认对first升序，当first相同时对second升序；通常有以下的一些定义和初始化的一些方法：
- pair<T1, T2> p;
- pair<T1, T2> p(v1, v2);
- make_pair(v1, v2)
上述第一种方法是定义了一个空的pair对象p，第二种方法是定义了包含初始值为v1和v2的pair对象p。第三种方法是以v1和v2值创建的一个新的pair对象。其中p.first对应的是键，p.second对应的是值
技巧：通过tie获取pair元素值
在某些清况函数会以pair对象作为返回值时，可以直接通过std::tie进行接收。比如：
std::pair<std::string, int> getPreson() {
return std::make_pair("Sven", 25);
}
int main(int argc, char **argv) {
std::string name;
int ages;
std::tie(name, ages) = getPreson();
std::cout << "name: " << name << ", ages: " << ages << std::endl;
return 0;
}
map的基本操作函数：
begin() 返回指向map头部的迭代器
clear(） 删除所有元素
count() 返回指定元素出现的次数
empty() 如果map为空则返回true
end() 返回指向map末尾的迭代器
equal_range() 返回特殊条目的迭代器对
erase() 删除一个元素
find() 查找一个元素,找不到返回q.end(),找到返回那个键的iterator
get_allocator() 返回map的配置器
insert() 插入元素
key_comp() 返回比较元素key的函数
lower_bound() 返回键值>=给定元素的第一个位置
max_size() 返回可以容纳的最大元素个数
rbegin() 返回一个指向map尾部的逆向迭代器
rend() 返回一个指向map头部的逆向迭代器
size() 返回map中元素的个数
swap() 交换两个map
upper_bound() 返回键值>给定元素的第一个位置
value_comp() 返回比较元素value的函数
这里着重讲讲insert这个操作：
// 定义一个map对象
map<int, string> mp;
// 第一种 用insert函數插入pair
mp.insert(pair<int, string>(001, "ABC"));
// 第二种 用insert函数插入value_type数据
mp.insert(map<int, string>::value_type(001, "ABC"));
// 第三种 用"array"方式插入
mp[123] = "ABC";
mp[123] = "abc";
用insert函数插入数据，在数据的 插入上涉及到集合的唯一性这个概念，即当map中有这个关键字时，insert操作是不能在插入数据的，但是用数组方式就不同了，它可以覆盖以前该关键字对应的值。
关于map容器的insert成员的返回值说明：
（1）map对象中一个给定键只对应一个元素。如果试图插入的元素所对应的键已在容器中，则insert将不做任何操作；
（2）含有一个或一对迭代器形参的insert函数版本如：m.insert(beg,end)，并不说明明是否有或有多少个元素插入到容器中。
（3）但是，带有一个键-值pair形参的insert版本将返回一个值：包含一个迭代器和一个bool值得pair对象，其中迭代器指向map中具有相应键的元素，而bool值则表示是否插入了该元素。如果该键不在容器中，则插入新元素，且bool值为ture；如果该键已在容器中，则其关联的值保持不变，返回bool值为false。在这两种情况下，迭代器都将指向具有给定键的元素。
所以在看见pair<map<string,vector<string> >::iterator,bool> ret = children.insert(make_pair(surname,chd));这么长的一句话时，不要害怕，细细分析。
pair里面的两个元素的类型分别是：map<string,vector<string> >::iterator，和bool。这个pair类型变量ret是insert操作的返回值。前面这个迭代器类型的元素是指向map中具有相应键的元素。
---------------------
作者：陈德胜
来源：CSDN
原文：https://blog.csdn.net/chendesheng1988/article/details/14108937
版权声明：本文为博主原创文章，转载请附上博文链接！
注意这里有个东西要注意一下，当我们用map<struct node,int> 这样存储的时候，会出现一个现象，如图：
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<bitset>
#include<cassert>
#include<cctype>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<deque>
#include<iomanip>
#include<list>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<vector>
# include <unordered_map>
using namespace std;
//extern "C"{void *__dso_handle=0;}
typedef long long ll;
typedef long double ld;
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
struct node{
public:
string s;
int id;
bool operator<(const node& x)const{
return this->s < x.s;
}
};
vector<vector<int> > q(20);
int main()
{
map<node,int> q;
node a = {"lala",2};
node b = {"qwe",3} ;
node c = {"lala",4};
// q[a] = 1;
// q[b] = 2;
// q[c] = 3;
q.insert(make_pair(a,1));
q.insert(make_pair(b,2));
q.insert(make_pair(c,3));
cout<<q.size()<<endl;
for(auto i:q){
cout<<i.first.s<<' '<<i.first.id<<i.second<<endl;
}
return 0;
}
（这里你会发现后面的那个c明明跟a不一样，只有里面的string是一样的，按照map来说，应该来说是不一样的，但是这里就根本存不进去，我觉得这跟map底层机制有关，后面看看源码再来解释）
但是我们可以使用下列的multimap这个容器来做
multimap
multimap多重映照容器:容器的数据结构采用红黑树进行管理
- multimap的所有元素都是pair:第一元素为键值(key),不能修改;第二元素为实值(value),可被修改
- multimap特性以及用法与map完全相同，唯一的差别在于:
- 允许重复键值的元素插入容器(使用了RB-Tree的insert_equal函数)
- 因此:
- 键值key与元素value的映照关系是多对多的关系
- 没有定义[]操作运算
- 使用multimap必须使用宏语句#include
#include <iostream>
#include <string>
#include <map>
int main(int argc, char* argv[])
{
std::multimap<std::string, int> myMultiMap;
// 插入
myMultiMap.insert(std::pair<std::string, int>("Jack", 1));
myMultiMap.insert(std::pair<std::string, int>("Jack", 2));
myMultiMap.insert(std::pair<std::string, int>("Bob", 1));
myMultiMap.insert(std::pair<std::string, int>("Navy", 3));
myMultiMap.insert(std::pair<std::string, int>("Demo", 4));
myMultiMap.insert(std::pair<std::string, int>("Bob", 5));
// 遍历
std::cout << "================All member"<< std::endl;
for (std::multimap<std::string, int>::iterator iter = myMultiMap.begin(); iter != myMultiMap.end(); ++iter)
{
std::cout << (*iter).first << ":" << (*iter).second << std::endl;
}
// 统计key为"Jack"的数目
std::string strFind = "Jack";
unsigned int uCount = myMultiMap.count(strFind);
if (uCount == 0)
{
std::cout << "================Count " << strFind << ":0"<< std::endl;
}
else
{
std::cout << "================Count " << strFind << ":" << uCount << std::endl;
std::multimap<std::string, int>::iterator iter = myMultiMap.find(strFind);
if (iter != myMultiMap.end())
{
for (unsigned int i = 0; i < uCount; ++i)
{
std::cout << (*iter).first << ":" << (*iter).second << std::endl;
iter++;
}
}
}
std::cout << "================use equal_range"<< std::endl;
typedef std::multimap<std::string, int>::iterator MultiMapIterator;
std::pair<MultiMapIterator, MultiMapIterator> iterPair = myMultiMap.equal_range("Jack");
for (MultiMapIterator it = iterPair.first; it != iterPair.second; ++it)
{
std::cout << (*it).first << ":" << (*it).second << std::endl;
}
// 删除所有key为"Bob"的键值对
myMultiMap.erase("Bob");
std::cout << "================After erase Bob"<< std::endl;
for (std::multimap<std::string, int>::iterator iter = myMultiMap.begin(); iter != myMultiMap.end(); ++iter)
{
std::cout << (*iter).first << ":" << (*iter).second << std::endl;
}
// 删除重复的key
MultiMapIterator iter = myMultiMap.find("Jack");
myMultiMap.erase(iter);
std::cout << "================Use unique key, erase \"Jack\" " << std::endl;
for (std::multimap<std::string, int>::iterator iter = myMultiMap.begin(); iter != myMultiMap.end(); ++iter)
{
std::cout << (*iter).first << ":" << (*iter).second << std::endl;
}
return 0;
}
unordered_map
unordered_map内部是一个unordered_map一般是由一个大vector，vector元素节点可挂接链表来解决冲突，来实现，也就是实现了哈希表，因此其元素的排列顺序是杂乱的，无序的
（unordered_map 就是 boost 里面的 hash_map 实现）
hash_map其插入过程是：
- 得到key
- 通过hash函数得到hash值
- 得到桶号(一般都为hash值对桶数求模)
- 存放key和value在桶内。
其取值过程是:
5. 得到key
6. 通过hash函数得到hash值
7. 得到桶号(一般都为hash值对桶数求模)
8. 比较桶的内部元素是否与key相等，若都不相等，则没有找到。
9. 取出相等的记录的value。
注意：unordered_map在相同元素个数下，所使用的内存总是比map多
使用用法：
q.count(n); //通过键来寻找，若存在返回1
q.erase(迭代器); // 通过迭代器来删除
q.erase(值)； //通过键来删除
unordered_multimap
unordered_multimap 是无序关联容器，支持等价的关键（一个 unordered_multimap 可含有每个关键值的多个副本）和将关键与另一类型的值关联。 unordered_multimap 类支持向前迭代器。搜索、插入和移除拥有平均常数时间复杂度。
元素在内部不以任何特定顺序排序，而是组织到桶中。元素被放进哪个桶完全依赖于其关键的哈希。这允许到单独元素的快速访问，因为哈希一旦计算，则它指代元素被放进的准确的桶。
不要求此容器的迭代顺序稳定（故例如 std::equal 不能用于比较二个 std::unordered_multimap ），除了关键比较等价（以 key_eq() 为比较器比较相等）的每组元素在迭代顺序中组成相接的子范围，它亦可用 equal_range() 访问。
具体用法跟上面的讲到的unordered_map基本一样，只不过这个是可以关键字重复的
#include<iostream>
#include<unordered_map>
using namespace std;
int main() {
unordered_multimap<int, int> myUnorderedMultiMap = { {2, 10},{1, 20},{3,30} };
cout << "键值对序列：" << endl;
for (auto &item : myUnorderedMultiMap) {
cout << item.first << " -> " << item.second << endl;
}
//插入元素
myUnorderedMultiMap.insert({ 0, 100 });
cout << "插入 （0, 100）键值对后：" << endl;
for (auto &item : myUnorderedMultiMap) {
cout << item.first << " -> " << item.second << endl;
}
//按key删除元素
myUnorderedMultiMap.erase(0);
cout << "移除0对应的键值对后：" << endl;
for (auto &item : myUnorderedMultiMap) {
cout << item.first << " -> " << item.second << endl;
}
//按迭代器删除元素
myUnorderedMultiMap.erase(myUnorderedMultiMap.begin());
cout << "移除map中第一个键值对后：" << endl;
for (auto &item : myUnorderedMultiMap) {
cout << item.first << " -> " << item.second << endl;
}
//清空map
myUnorderedMultiMap.clear();
cout << "清空map后：" << endl;
for (auto &item : myUnorderedMultiMap) {
cout << item.first << " -> " << item.second << endl;
}
return 0;
}
703
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
