map容器的insert用法总结

简介谨记 value_type是pair类型的同义词，K为键类型，V为键所关联的值的类型map对象中一个给定键只对应一个元素。如果试图插入的元素所对应的键已经在容器中，则insert 将不做任何操作。通常来说，下标操作符返回左值。它返回的左值是特定键所关联的值。有别于vector或string类型，map下标操作符返回的类型与对map迭代器进行解引用获得的类型不

啊拉丁的鱼

25129人浏览 · 2018-01-25 20:02:07

啊拉丁的鱼 · 2018-01-25 20:02:07 发布

简介

谨记 value_type是pair< const K, V>类型的同义词，K为键类型，V为键所关联的值的类型
map对象中一个给定键只对应一个元素。如果试图插入的元素所对应的键已经在容器中，则insert 将不做任何操作。
通常来说，下标操作符返回左值。它返回的左值是特定键所关联的值。
有别于vector或string类型，map下标操作符返回的类型与对map迭代器进行解引用获得的类型不相同。
map迭代器返回value_type类型的值—––包括const key_type 和mapped_type类型成员的pair对象；下标操作符返回一个mapped_type类型的值。
带有一个键—值pair 形参的insert 版本将返回一个值：包含一个迭代器和一个bool 值的pair 对象。其中迭代器指向map中具有相应键的元素，而bool 值则表示是否插入了该元素。如果该元素已经在容器中，则其关联的值保持不变，返回bool值为false；如果该键不在容器中，则插入新元素，且bool值为true。

=============================================================================================

map 容器的insert成员与顺序容器的类似，但有一点要注意：必须考虑键的作用。键影响了实参的类型：插入单个元素的insert版本使用键–值 pair 类型的参数。
类似的，对于参数为一对迭代器的版本，迭代器必须指向键–值 pair 类型的元素。另一个差别则是：map容器的接受单个值的insert版本的返回类型。

这里写图片描述

1、以insert代替下标运算

这里写图片描述
- 使用下标给map容器添加新元素时，元素的值部分将采用值初始化。通常，我们会立即为其赋值，其实就是对同一个对象进行初始化并赋值。而插入元素的另一个方法是：直接使用insert 成员

word_count.insert(map<string,int>::value_type("Anna",1));
 
 1

这个insert 函数的实参是 map< string,int>::value_type(“Anna”,1)。是一个新创建的pair 对象，将直接插入到map 容器中。谨记 value_type是pair< const K, V>类型的同义词，K为键类型，V为键所关联的值的类型
insert 的实参创建了一个适当的pair类型新对象，该对象将插入到map容器。
在添加新的map元素时，使用insert 成员可避免使用下标操作符所带来的副作用：不必要的初始化。
- 传递给insert 的实参相当笨拙，可用两种方式简化：使用 make_pair 或 typedef

word_count.insert(make_pair("Anna",1));
 
 1

typedef map<string,int>::value_type valType;
word_count.insert(valType("Anna",1););

例子：

[cpp] view plain copy

#include <stdio.h>
#include <string>
#include <map>
#include <memory>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
map<int, int> imap;
map<int, int> jmap;
jmap[1] = 1;
jmap[2] = 2;
imap.insert(jmap.begin(), jmap.end());
map<int, int>::iterator iter = imap.begin();
for (; iter != imap.end(); iter++)
printf("iter->first: %d, iter->second: %d\n", iter->first, iter->second);
getchar();
return 0;
}

运行结果如下：

[cpp] view plain copy

iter->first: 1, iter->second: 1
iter->first: 2, iter->second: 2

注意: insert(iter1, iter2)返回值是void

例子：

[cpp] view plain copy

#include <stdio.h>
#include <string>
#include <map>
#include <memory>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
map<int, int> jmap;
jmap[1] = 1;
jmap[2] = 2;
pair<map<int, int>::iterator, bool> pret = jmap.insert(pair<int, int>(3, 3));
printf("pret.second: %d, pret.first->first: %d, pret.first->second: %d\n", pret.second, pret.first->first, pret.first->second);
pret = jmap.insert(pair<int, int>(1, 1));
printf("pret.second: %d, pret.first->first: %d, pret.first->second: %d\n", pret.second, pret.first->first, pret.first->second);
getchar();
return 0;
}

运行结果为：

[cpp] view plain copy

pret.second: 1, pret.first->first: 3, pret.first->second: 3
pret.second: 0, pret.first->first: 1, pret.first->second: 1

分析：insert(pair<...>) 版本返回值是一个pair结构，其中第一个元素是一个迭代器，第二个元素是一个bool类型，根据以上结果：如果原来的map中不含有插入的元素，则bool为true，迭代器指向插入的元素；如果map中已经含有插入的元素了，则bool为false，返回的迭代器指向对应的map中已经存在的元素

例子：

[cpp] view plain copy

#include <stdio.h>
#include <string>
#include <map>
#include <memory>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
map<int, int> imap;
map<int, int> jmap;
jmap[1] = 1;
jmap[2] = 2;
imap.insert(jmap.begin(), jmap.end());
map<int, int>::iterator ret = imap.insert(imap.begin(), pair<int, int>(1, 1));
printf("ret->first: %d, ret->end: %d\n", ret->first, ret->second);
ret = imap.insert(imap.begin(), pair<int, int>(3, 3));
printf("ret->first: %d, ret->end: %d\n", ret->first, ret->second);
getchar();
return 0;
}

运行结果为：

[cpp] view plain copy

ret->first: 1, ret->end: 1
ret->first: 3, ret->end: 3

分析：insert(iter, pair<...>)返回一个指向插入元素的迭代器，如果map中已经存在元素，则返回的迭代器指向原先map中已经存在的元素

例子：

[cpp] view plain copy

#include <stdio.h>
#include <string>
#include <map>
#include <memory>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
map<int, int> kmap;
//std::initializer_list<pair<int, int> > list = { pair<int, int>(10, 10), pair<int, int>(20, 20), pair<int, int>(30, 30) }; //error
kmap.insert({ pair<int, int>(10, 10), pair<int, int>(20, 20), pair<int, int>(30, 30) });
map<int, int>::iterator iter = kmap.begin();
for (; iter != kmap.end(); iter++)
printf("iter->first: %d, iter->second: %d\n", iter->first, iter->second);
//MapInsert();
getchar();
return 0;
}

运行结果为：

[cpp] view plain copy

iter->first: 10, iter->second: 10
iter->first: 20, iter->second: 20
iter->first: 30, iter->second: 30

分析：这里的insert是使用void insert(_XSTD initializer_list<value_type> _Ilist)这个重载版本的，返回值为void，在外面定义initializer_list再传进去会出错，不知道为什么。

例子：

[cpp] view plain copy

#include <stdio.h>
#include <string>
#include <map>
#include <memory>
using namespace std;
class People
{
public:
People(const char* name, int age)
{
printf("constructor People\n");
strcpy(m_name, name);
m_age = age;
}
virtual ~People()
{
printf("destructor People\n");
}
public:
virtual void Print() = 0;
protected:
char m_name[10];
int m_age;
};
class Stu: public People
{
public:
Stu(const char* name, int age) : People(name, age)
{
printf("constructor Stu\n");
}
~Stu()
{
printf("destructor Stu\n");
}
public:
void Print()
{
printf("This is Stu Print, name: %s, age: %d\n", m_name, m_age);
}
};
class Worker : public People
{
public:
Worker(const char* name, int age) : People(name, age)
{
printf("constructor worker\n");
}
~Worker()
{
printf("destructor worker\n");
}
public:
void Print()
{
printf("This is Worker Print, name: %s, age: %d\n", m_name, m_age);
}
};
void MapInsert()
{
typedef map<string, shared_ptr<People> >::iterator Iterator;
typedef pair<string, shared_ptr<People> > Pair;
pair<string, int> stu_pair[3] = { make_pair("Peter", 10), make_pair("Rei", 14), make_pair("Kai", 16)};
pair<string, int> wor_pair[3] = { make_pair("Jet", 20), make_pair("Piker", 24), make_pair("Ein", 26) };
map<string, shared_ptr<People> > insert_map;
for (int i = 0; i < 3; i++)
pair<Iterator, bool> ret = insert_map.insert(Pair(stu_pair[i].first, make_shared<Stu>(stu_pair[i].first.c_str(), stu_pair[i].second)));
for (int i = 0; i < 3; i++)
pair<Iterator, bool> ret = insert_map.insert(Pair(wor_pair[i].first, make_shared<Worker>(wor_pair[i].first.c_str(), wor_pair[i].second)));
Iterator iter = insert_map.begin();
for (; iter != insert_map.end(); iter++)
{
printf("%s: ", iter->first.c_str());
iter->second->Print();
}
}
int _tmain(int argc, _TCHAR* argv[])
{
MapInsert();
getchar();
return 0;
}

运行结果如下：

[cpp] view plain copy

constructor Stu
constructor People
constructor worker
constructor People
constructor worker
constructor People
constructor worker
Ein: This is Worker Print, name: Ein, age: 26
Jet: This is Worker Print, name: Jet, age: 20
Kai: This is Stu Print, name: Kai, age: 16
Peter: This is Stu Print, name: Peter, age: 10
Piker: This is Worker Print, name: Piker, age: 24
Rei: This is Stu Print, name: Rei, age: 14
destructor Stu
destructor People
destructor worker
destructor People
destructor Stu
destructor People
destructor Stu
destructor People
destructor worker
destructor People
destructor worker
destructor People

分析：map中插入不同于map指定的元素类别的时候，如果插入的类别可以转换成map允许插入的类别的话，map会帮你自动转换，如果不能转换则不能插入

map<int, int> imap;

imap.insert(pair<int, double>(10, 10.2)) //可以插入，但会损失精度

imap.insert(pair<double, char>(10.1, 'c')) //可以插入，同样会损失精度

imap.insert(pair<int, string>(10, "s")) //编译出错

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

沃云统一开发平台介绍

沃云集成平台研发平台介绍1.平台优势2.平台原理3.研发平台使用方法4.遇到的问题5.现阶段实现的功能6.后续需要补充的功能和优化内容研发平台介绍1.平台优势解决孤岛式应用，实现能力共享；现有系统框架过于复杂，跨系统业务处理成本居高不下，协同服务共享，降低运维成本；提高项目应用资源监控能力，改善资源利用率；业务微服务化，快速发布、快速部署，快速响应业务需求变化；沃云平台不仅提供了自动化的、可快速部

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

云原生

基于docker的test-containers环境百宝箱

笔者语录：我开了个公众号【Java你我他】，欢迎大家关注。在很多时候，程序猿们更关注代码本身，而不愿意把时间花费在环境搭建上，这也是Docker变得越来越受欢迎的原因之一。test-containe是Docker生态圈中的一颗新星，其主要针对测试领域、背靠Docker实现环境百宝箱功能。 test-containers：你要的环境，我都有~ 假设我们现在需要一个redis-clust