map容器的insert用法总结

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

啊拉丁的鱼

25498人浏览 · 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全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

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

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