1.STL的基本概念

STL(Standard Template Library, 标准模板库), STL在广义上分为容器(container), 算法(algorithm), 迭代器(iterator), 容器和算法之间通过迭代器进行无缝连接!!! (这点很重要); STL几乎所有的代码都采用了模板类或者模版函数,这相比于传统的由函数和类组成的库来说提供了更好的代码重用的机会;

1.2STL的六大组件

六大组件分别为: 容器, 算法, 迭代器, 仿函数, 适配器, 空间配置器

1. 容器: 存放数据
2. 算法: 操作数据
3. 迭代器: 算法通过迭代器去操作容器中的数据
4. 仿函数: 为算法提供更多的策略
5. 适配器: 为算法提供更多参数的接口(比如一个算法可能只留了一个参数,但是我们需要传两个过去)
6. 空间配置器: 为算法和容器 动态分配和管理空间(最终要的东西, 但是对我们来说不关心)

每个容器对应一个迭代器, 这个容器具体一个数据多大只有他的迭代器知道, 一个算法操作一个容器但是关于容器的具体信息迭代器知道, 算法只要拿到迭代器就行了, 比如vector<int>和vector<double>每次遍历下一个元素要++ – 多少字节肯定不一样;

质变算法 : 更改了区间的内容:拷贝, 删除, 替换等
非质变算法: 不更改区间内容: 查找, 计数, 遍历等

2.string类

2.1string的基本概念

C 风格字符串(以空字符结尾的字符数组)太过复杂难于掌握，不适合大程序的开发，所以 C++标准库定义了一种 string 类，定义在头件。
String 和 c 风格字符串对比：

Char * 是一个指针，String 是一个类
string 封装了 char * ，管理这个字符串，是一个 char 型的容器。

String 封装了很多实用的成员方法：
查找 find，拷贝 copy，删除 delete 替换 replace，插入 insert 不用考虑内存释放和越界string 管理 char*所分配的内存。每一次 string 的复制，取值都由 string 类负责维护，不用担心复制越界和取值越界等

2.2string容器常用操作

1）string 构造函数

string();//创建一个空的字符串 例如: string str;
string(const string& str);//使用一个 string 对象初始化另一个 string 对象
string(const char* s);//使用字符串 s 初始化
string(int n, char c);//使用 n 个字符 c 初始化 v

2）string 基本赋值操作

string& operator=(const char* s);//char*类型字符串 赋值给当前的字符串
string& operator=(const string &s);//把字符串 s 赋给当前的字符串
string& operator=(char c);//字符赋值给当前的字符串
//assign的英文意思是分配, 这里就是复制的意思
//看到char * 和string都是字符串的意思
string& assign(const char *s);//把字符串 s 赋给当前的字符串
string& assign(const char *s, int n);//把字符串 s 的前 n 个字符赋给当前的字符串
string& assign(const string &s);//把字符串 s 赋给当前字符串
string& assign(int n, char c);//用 n 个字符 c 赋给当前字符串
string& assign(const string &s, int start, int n);//将 s 从 start 开始 n 个字符赋值
给字符串

3）string 存取字符操作

//[] 越界不会抛出异常 at方法 越界会抛出异常
char& operator[](int n);//通过[]方式取字符
char& at(int n);//通过 at 方法获取字符

4）string 拼接操作

string& operator+=(const string& str);//重载+=操作符
string& operator+=(const char* str);//重载+=操作符
string& operator+=(const char c);//重载+=操作符
string& append(const char *s);//把字符串 s 连接到当前字符串结尾
string& append(const char *s, int n);//把字符串 s 的前 n 个字符连接到当前字符串结尾
string& append(const string &s);//同 operator+=()
string& append(const string &s, int pos, int n);//把字符串 s 中从 pos 开始的 n 个字符
连接到当前字符串结尾
string& append(int n, char c);//在当前字符串结尾添加 n 个字符 c

5）string 查找和替换
先介绍一下常量成员函数,比如下面这个
int find(const string& str, int pos = 0) const;
常量成员函数中不能修改改对象中的成员变量的值.

例如，Date 类中的三个常量成员函数：GetYear()、GetMonth() 和 GetDay()

class Date {
public:int GetYear() const { return y; }int GetMonth() const { return m; }int GetDay() const { return d; }void AddYear(int n); // add n years
private:int y, m, d; 
};　

当在 GetYear() 中，修改成员变量 y 时，编译会报错

// error : attempt to change member value in const function
int Date::GetYear() const
{return ++y;
}

具体细节查看这篇博客

int find(const string& str, int pos = 0) const; //查找 str 第一次出现位置, 从 pos 开
始查找
int find(const char* s, int pos = 0) const; //查找 s 第一次出现位置,从 pos开始查找
int find(const char* s, int pos, int n) const; //从 pos 位置查找 s 的前 n 个字符第一
次位置
int find(const char c, int pos = 0) const; //查找字符 c 第一次出现位置
int rfind(const string& str, int pos = npos) const;//查找 str 最后一次位置, 从 pos
开始查找
int rfind(const char* s, int pos = npos) const;//查找 s 最后一次出现位置,从pos 开始查
找
int rfind(const char* s, int pos, int n) const;//从 pos 查找 s 的前 n 个字符最后一次
位置
int rfind(const char c, int pos = 0) const; //查找字符 c 最后一次出现位置
string& replace(int pos, int n, const string& str); //替换从 pos 开始 n 个字符为字符
串 str
string& replace(int pos, int n, const char* s); //替换从 pos 开始的 n 个字符为字符串
s

6）string 比较操作

/*
compare 函数在>时返回 1，<时返回 -1，==时返回 0。
比较区分大小写，比较时参考字典顺序，排越前面的越小。
大写的 A 比小写的 a 小。
*/
int compare(const string &s) const;//与字符串 s 比较
int compare(const char *s) const;//与字符串 s 比较
重载了> < ==等关运算符

7）string 子串

string substr(int pos = 0, int n = npos) const;//返回由 pos 开始的 n 个字符组成的字符
串

8）string插入和删除操作

string& insert(int pos, const char* s); //插入字符串
string& insert(int pos, const string& str); //插入字符串
string& insert(int pos, int n, char c);//在指定位置插入 n 个字符 c
string& erase(int pos, int n = npos);//删除从 Pos 开始的 n 个字符

9）string 和 c-style 字符串转换

//string 转 char*
string str = "itcast";
const char* cstr = str.c_str();
char * cstr2 = (char *)str.c_str();//c_str返回的是一个const char * 类型,需要强转一下
//char* 转 string
char* s = "itcast";
string str(s);

在 c++中存在一个从 const char 到 string 的隐式类型转换，却不存在从一个 string对象到 Cstring 的自动类型转换。对于 string 类型的字符串，可以通过 cstr()函数返回 string 对象对应的 C_string. 通常，程序员在整个程序中应坚持使用 string 类对象，直到必须将内容转化为 char 时才将其转换为 C_string. 提示: 为了修改 string 字符串的内容，下标操作符[]和 at 都会返回字符的引用。但当字符串的内存被重新分配之后，可能发生错误。

string s = "abcdefg";
char& a = s[2];
char& b = s[3];
a = '1';
b = '2';
cout << s << endl;
cout << (int*)s.c_str() << endl;
s = "----------------------------";
//a = '1';
//b = '2';
cout << s << endl;
cout << (int*)s.c_str() << endl;
//打印结果如下:
ab12efg
0x25adc38
----------------------------
0x25adc68
//原因
在你的代码中，你使用 s.c_str() 打印了字符串 s 的内存地址。在第一次打印后，你将 s 的值更改为了 "----------------------------"，然后再次打印 s.c_str() 的地址。
当你修改 s 的值时，string 类会分配新的内存来存储新的字符串内容。因此，第一次打印 s.c_str() 的地址与第二次打印的地址不一样。
在第一次打印之后，你将 s 的值更改为了 "----------------------------"。这导致 string 类会分配新的内存来存储新的字符串。由于字符串的长度不同，新的字符串可能需要更多或更少的内存来存储。因此，在第二次打印 s.c_str() 的地址时，你看到的是新分配的内存地址。
值得注意的是，在每次修改 s 的值之后，它的内存地址可能会发生变化。这是因为 string 类会根据需要进行内存重分配，以容纳新的字符串内容。因此，两次打印 s.c_str() 的地址不同是正常的行为。

3.vector容器

3.1vector容器基本概述

vector是一个单端动态的数组

v.begin():获取容器的起始迭代器（指向第0个元素）
v.end():获取容器的结束迭代器（指向最后一个元素的下一个位置）

还记得之前说的一个容器对应一个迭代器吗?
比如这里vector::iterator是vector这个容器的迭代器;
通过vector::iterator it = v.begin()这样的方式获得
可以把迭代器看做指针但不要单纯的认为它是指针
(*it).name = it -> name
一旦遇到复杂的迭代器 it -> name可能不识别,因此推荐用(*it).name
1）vector 构造函数

vector<T> v; //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end());//将 v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem);//构造函数将 n 个 elem 拷贝给本身。
vector(const vector &vec);//拷贝构造函数。

2）vector 常用赋值操作

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将 n 个 elem 拷贝赋值给本身。
vector& operator=(const vector &vec);//重载等号操作符
swap(vec);// 将 vec 与本身的元素互换。

3）vector 大小操作
注意vector容器的容量和vector容器的大小是不一样的
vector容器的容量 >= vector容器的大小

size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(int num);//重新指定容器的长度为 num，若容器变长，则以默认值填充新位置。如果容器变短，
则末尾超出容器长度的元素被删除。
resize(int num, elem);//重新指定容器的长度为 num，若容器变长，则以 elem 值填充新位置。如果
容器变短，则末尾超出容器长>度的元素被删除。
capacity();//容器的容量
reserve(int len);//容器预留 len 个元素长度，预留位置不初始化，元素不可访问。

4）vector 数据存取操作

at(int idx); //返回索引 idx 所指的数据，如果 idx 越界，抛出 out_of_range 异常。
operator[];//返回索引 idx 所指的数据，越界时，运行直接报错
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素

5）vector 插入和删除操作

insert(const_iterator pos, int count,ele);//迭代器指向位置 pos 插入 count个元素 ele.
push_back(ele); //尾部插入元素 ele
pop_back();//删除最后一个元素
erase(const_iterator start, const_iterator end);//删除迭代器从 start 到 end 之间的元
素
erase(const_iterator pos);//删除迭代器指向的元素
clear();//删除容器中所有元素

6）巧用 swap 收缩内存空间

vector<int> v1;
v1.reserve(1000);
v1.push_back(10);
v1.push_back(20);
v1.push_back(30);
v1.push_back(40);
cout<<"容量:"<<v1.capacity()<<", 大小:"<<v1.size()<<endl;//1000 4
//resize只能修改大小 不能修改容量
//v1.resize(4);
vector<int>(v1).swap(v1);//匿名对象vector<int>(v1)在这条语句执行完后会自动释放空间的
//vector<int>(v1)这种赋值方式 是 v1有多少元素赋值过来多少,而不是v1容量多大赋值过来多少
cout<<"容量:"<<v1.capacity()<<", 大小:"<<v1.size()<<endl;//4 4

7）reserve 预留空间

#include<iostream>
#include<vector>
using namespace std;
int main(){
vector<int> v;
//预先开辟空间
v.reserve(100000);
int* pStart = NULL;
int count = 0;
for (int i = 0; i < 100000;i ++){
v.push_back(i);
if (pStart != &v[0]){
pStart = &v[0];
count++;
}
}
cout << "count:" << count << endl;
return 0;
}

4.deque容器

4.1deque容器的基本概念

Vector 容器是单向开口的连续内存空间，deque 则是一种双向开口的连续线性空间。所谓的双向开口，意思是可以在头尾两端分别做元素的插入和删除操作，当然，vector 容器也可以在头尾两端插入元素，但是在其头部操作效率奇差，无法被接受。

Deque 容器和vector 容器最大的差异，一在于 deque 允许使用常教项时间对头端进行元素的插入和删除操作。二在于 deque 没有容量的概念，因为它是动态的以分段连续空间组合而成，随时可以增加一段新的空间并链接起来，换句话说，像vector 那样，"日空间不足而重新配置一块更大空间，然后复制元素，再释放日空间"这样的事情在 deque 身上是不会发生的。也因此，deque 没有必须要提供所谓的空间保留(reserve)功能.虽然deque 容器也提供了 Random Access Iterator,但是它的迭代器并不是普通的指针，其复杂度和 vector 不是个量级，这当然影响各个运算的层面。因此，除非有必要，我们应该尽可能的使用vector，而不是deque。对deque 进行的排序操作，为了最高效率，可将 deque 先完整的复制到一个vector中，对vector容器进行排序，再复制回 deque

4.2deque容器的实现原理

Deque 容器是连续的空间，至少逻辑上看来如此，连续现行空间总是令我们联想到array和vectorarray 无法成长，vector 虽可成长却只能向尾端成长，而且其成长其实是一个假象，事实上(1)申请更大空间(2)原数据复制新空间(3)释放原空间三步骤，如果不是vector 每次配置新的空间时都留有余裕，其成长假象所带来的代价是非常昂贵的。Deque 是由一段一段的定量的连续空间构成。一旦有必要在deque 前端或者尾端增加新的空间，便配置一段连续定量的空间，申接在deque 的头端或者尾端。Deque 最大的工作就是维护这些分段连续的内存空间的整体性的假象，并提供随机存取的接口，避开了重新配置空间，复制，释放的轮回，代价就是复杂的迭代器架构。既然 deque 是分段连续内存空间，那么就必须有中央控制，维持整体连续的假象，数据结构的设计及迭代器的前进后退操作颇为繁琐。Deque 代码的实现远比vector 或list都多得多。Deque 采取一块所谓的map(注意，不是 STL的 map 容器作为主控，这里所谓的 map是一小块连续的内存空间，其中每一个元素(此处成为一个结点都是一个指针，指向另一段连续性内存空间，称作缓冲区。缓冲区才是deque 的存储空间的主体。

4.3deque常用API

1）deque 构造函数

deque<T> deqT;//默认构造形式
deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem);//构造函数将 n 个 elem 拷贝给本身。
deque(const deque &deq);//拷贝构造函数。

2）deque 赋值操作

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将 n 个 elem 拷贝赋值给本身。
deque& operator=(const deque &deq); //重载等号操作符
swap(deq);// 将 deq 与本身的元素互换

2）deque 赋值操作

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将 n 个 elem 拷贝赋值给本身。
deque& operator=(const deque &deq); //重载等号操作符
swap(deq);// 将 deq 与本身的元素互换

3）deque 大小操作

deque.size();//返回容器中元素的个数
deque.empty();//判断容器是否为空
deque.resize(num);//重新指定容器的长度为 num,若容器变长，则以默认值填充新位置。如果容器变
短，则末尾超出容器长度的元素被删除。
deque.resize(num, elem); //重新指定容器的长度为 num,若容器变长，则以 elem 值填充新位置,如
果容器变短，则末尾超出容器长度的元素被删除。

4）deque 双端插入和删除操作

push_back(elem);//在容器尾部添加一个数据
push_front(elem);//在容器头部插入一个数据
pop_back();//删除容器最后一个数据
pop_front();//删除容器第一个数据

5）deque 数据存取

at(idx);//返回索引 idx 所指的数据，如果 idx 越界，抛出 out_of_range。
operator[];//返回索引 idx 所指的数据，如果 idx 越界，不抛出异常，直接出错。
front();//返回第一个数据。
back();//返回最后一个数据

6）deque 插入操作

insert(pos,elem);//在 pos 位置插入一个 elem 元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在 pos 位置插入 n 个 elem 数据，无返回值。
insert(pos,beg,end);//在 pos 位置插入[beg,end)区间的数据，无返回值。

7）deque 删除操作

clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除 pos 位置的数据，返回下一个数据的位置。

5. stack容器

stack 是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口，形式如图所示。stack 容器允许新增元素，移除元素，取得栈顶元素，但是除了最顶端外，没有任何其他方法可以存取 stack 的其他元素。换言之，stack 不允许有遍历行为。 有元素入栈的操作称为:push,将元素出 stack 的操作称为 pop。

Stack 所有元素的进出都必须符合”先进后出”的条件，只有 stack 顶端的元素，才有机会被外界取用。 Stack 不提供遍历功能，也不提供迭代器。

5.2stack常用API

1）stack 构造函数

stack<T> stkT;//stack 采用模板类实现， stack 对象的默认构造形式：
stack(const stack &stk);//拷贝构造函数

2）stack 赋值操作

stack& operator=(const stack &stk);//重载等号操作符

3）stack 数据存取操作

push(elem);//向栈顶添加元素
pop();//从栈顶移除第一个元素
top();//返回栈顶元素

4）stack 大小操作

empty();//判断堆栈是否为空
size();//返回堆栈的大小

6.queue容器

6.1 queue 容器基本概念

Queue 是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口，queue容器允许从一端新增元素，从另一端移除元素.

Queue 所有元素的进出都必须符合”先进先出”的条件，只有 queue 的顶端元素，才有机会被外界取用。
Queue 不提供遍历功能，也不提供迭代器。

6.2 queue常用API

queue<T> queT;//queue 采用模板类实现，queue 对象的默认构造形式：
queue(const queue &que);//拷贝构造函数
push(elem);//往队尾添加元素
pop();//从队头移除第一个元素
back();//返回最后一个元素
front();//返回第一个元素
queue& operator=(const queue &que);//重载等号操作符
empty();//判断队列是否为空
size();//返回队列的大小

7.list容器

7.1list 容器基本概念

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相较于vector 的连续线性空间(vector是线性的进行插入一个元素要移动很多元素很麻烦)，list 就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置或者释放一个元素的空间。因此，list 对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素的移除，list 永远是常数时间(但是链表进行查找的话就不是常数时间了)。 List 和vector 是两个最常被使用的容器。 List 容器是一个双向链表。
list的迭代器是双向迭代器,vector是随机迭代器, 因此list的迭代器不支持+2操作,只支持++,并且list的迭代器也不能用传统的stl的sort()reverse()函数,但是list类有自己的sort函数和reverse函数

采用动态存储分配，不会造成内存浪费和溢出 链表执行插入和删除操作十分方便，修改指针即可，不需 要移动大量元素 链表灵活，但是空间和时间额外耗费较大。

7.2 list常用API

1）list 构造函数

list<T> lstT;//list 采用采用模板类实现,对象的默认构造形式：
list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将 n 个 elem 拷贝给本身。
list(const list &lst);//拷贝构造函数。

2） list 数据元素插入和删除操作

push_back(elem);//在容器尾部加入一个元素
pop_back();//删除容器中最后一个元素
push_front(elem);//在容器开头插入一个元素
pop_front();//从容器开头移除第一个元素
insert(pos,elem);//在 pos 位置插 elem 元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在 pos 位置插入 n 个 elem 数据，无返回值。
insert(pos,beg,end);//在 pos 位置插入[beg,end)区间的数据，无返回值。
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除 pos 位置的数据，返回下一个数据的位置。
remove(elem);//删除容器中所有与 elem 值匹配的元素。

3）list 大小操作

size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(num);//重新指定容器的长度为 num，若容器变长，则以默认值填充新位置。如果容器变短，则末
尾超出容器长度的元素被删除。
resize(num, elem);//重新指定容器的长度为 num，若容器变长，则以 elem 值填充新位置。如果容器
变短，则末尾超出容器长度的元素被删除。

4）list 赋值操作

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将 n 个 elem 拷贝赋值给本身。
list& operator=(const list &lst);//重载等号操作符
swap(lst);//将 lst 与本身的元素互换。

5）list 数据的存取

front();//返回第一个元素。
back();//返回最后一个元素。

6）list 反转排序

//list的迭代器是双向迭代器,vector是随机迭代器, 因此list的迭代器不支持+2操作,只支持++,并且list的迭代器也不能用传统的stl的sort()reverse()函数,
//但是list类有自己的sort函数和reverse函数
reverse();//反转链表，比如 lst 包含 1,3,5 元素，运行此方法后，lst 就包含 5,3,1元素。
sort(); //list 排序

8.set/multiset容器

8.1 set/multiset 容器基本概念

set 的特性是。所有元素都会根据元素的键值自动被排序，set 的元素即是键值又是实值。

set 不允许两个元素有相同的键值。

set容器的迭代器是只读迭代器，不允许修改键值，会破坏set的内存布局。set内部的存储结构是一个平衡二叉树,如果可以通过迭代器修改set内部的值的话,那这个已经排序好的树就乱掉了

multiset 特性及用法和 set 完全相同，唯一的差别在于它允许键值重复。

8.2 set常用API

1）set 构造函数

set<T> st;//set 默认构造函数：
mulitset<T> mst; //multiset 默认构造函数:
set(const set &st);//拷贝构造函数

2）set 赋值操作

cset& operator=(const set &st);//重载等号操作符
swap(st);//交换两个集合容器

3）set 大小操作

size();//返回容器中元素的数目
empty();//判断容器是否为空

4）set 插入和删除操作

insert(elem);//在容器中插入元素。
clear();//清除所有元素
erase(pos);//删除 pos 迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(elem);//删除容器中值为 elem 的元素。

5）set 查找操作

find(key);//查找键 key 是否存在,若存在，返回该键的元素的迭代器；若不存在，返回 set.end();
count(key);//查找键 key 的元素个数
lower_bound(keyElem);//(二分法)返回第一个 key>=keyElem 元素的迭代器。注意这里是大于等于哦
upper_bound(keyElem);//(二分法)返回第一个 key>keyElem 元素的迭代器。
//容器内没有要找的元素的时候lower_bound和upper_bound就会相等
equal_range(keyElem);//返回容器中 key 与 keyElem 相等的上下限的两个迭代器
//equal_range返回的是一个pair<set<T>::const_iterator,set<T>::const_iterator>

8.3 对组（pair）

对组(pair)将一对值组合成一个值，这一对值可以具有不同的数据类型，两个值可以分别用 pair 的两个公有属性 first 和 second 访问。 类模板：template <class T1, class T2> struct pair. 如何创建对组?

//第一种方法创建一个对组
pair<string, int> pair1(string("name"), 20);
cout << pair1.first << endl; //访问 pair 第一个值
cout << pair1.second << endl;//访问 pair 第二个值
//第二种
pair<string, int> pair2 = make_pair("name", 30);
cout << pair2.first << endl;
cout << pair2.second << endl;
//pair=赋值
pair<string, int> pair3 = pair2;
cout << pair3.first << endl;
cout << pair3.second << endl;

9.map/multimap 容器

20.9.1 map/multimap 基本概念
Map 的特性是，所有元素都会根据元素的键值自动排序。Map 所有的元素都是pair,同时拥有实值和键值，pair 的第一元素被视为键值，第二元素被视为实值，map 不允许两个元素有相同的键值。 我们可以通过 map 的迭代器改变 map 的键值吗？答案是不行，因为 map 的键值关系到 map 元素的排列规则，任意改变 map键值将会严重破坏 map 组织。如果想要修改元素的实值，那么是可以的。 Map 和list 拥有相同的某些性质，当对它的容器元素进行新增操作或者删除操作时，操作之前的所有迭代器，在操作完成之后依然有效，当然被删除的那个元素的迭代器必然是个例外。 Multimap 和 map 的操作类似，唯一区别 multimap 键值可重复。Map 和 multimap 都是以红黑树为底层实现机制。

map容器：每个元素都是 键值-实值 成对存储，自动根据键值排序， 键值不能重复，不能修改。

9.2 map/multimap 常用 API

1）map 构造函数

map<T1, T2> mapTT;//map 默认构造函数:
map(const map &mp);//拷贝构造函数

2）map 赋值操作

map& operator=(const map &mp);//重载等号操作符
swap(mp);//交换两个集合容器

3） map 大小操作

size();//返回容器中元素的数目
empty();//判断容器是否为空

4）map 插入数据元素操作

map.insert(...); //往容器插入元素，返回 pair<iterator,bool>
map<int, string> mapStu;
// 第一种 通过 pair 的方式插入对象
mapStu.insert(pair<int, string>(3, "小张"));
// 第二种 通过 pair 的方式插入对象
mapStu.inset(make_pair(-1, "校长"));
// 第三种 通过 value_type 的方式插入对象
mapStu.insert(map<int, string>::value_type(1, "小李"));
// 第四种 通过数组的方式插入值
mapStu[3] = "小刘";
mapStu[5] = "小王";

通过第四种方式[]去获得map中的数据比较危险,如果map中没有map[67],那你在获得这个数据的时候是获得不到的,map还会自动为你创建一个67的键map[67]但是对应的value是啥就是随机的了
5） map 删除操作

clear();//删除所有元素
erase(pos);//删除 pos 迭代器所指的元素，返回下一个元素的迭代器。
erase(beg,end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(keyElem);//删除容器中 key 为 keyElem 的对组。

6）map 查找操作

find(key);//查找键 key 是否存在,若存在，返回该键的元素的迭代器；/若不存在，返回 map.end();
count(keyElem);//返回容器中 key 为 keyElem 的对组个数。对 map 来说，要么是 0，要么是 1。
对 multimap 来说，值可能大于 1。
lower_bound(keyElem);//返回第一个 key>=keyElem 元素的迭代器。
upper_bound(keyElem);//返回第一个 key>keyElem 元素的迭代器。
equal_range(keyElem);//返回容器中 key 与 keyElem 相等的上下限的两个迭代器

10.STL 容器使用时机

vector 的使用场景：比如软件历史操作记录的存储，我们经常要查看历史记录，比如上一次的记录，上上次的记录，但却不会去删除记录，因为记录是事实的描述。

deque 的使用场景：比如排队购票系统，对排队者的存储可以采用 deque，支持头端的快速移除，尾端的快速添加。如果采用 vector，则头端移除时，会移动大量的数据，速度慢。

vector 与 deque 的比较：

一：vector.at()比 deque.at()效率高，比如 vector.at(0)是固定的，deque 的开始位置 却是不固定的。
二：如果有大量释放操作的话，vector 花的时间更少，这跟二者的内部实现有关。

deque 支持头部的快速插入与快速移除，这是 deque 的优点。

list 的使用场景：比如公交车乘客的存储，随时可能有乘客下车，支持频繁的不确实位置元素的移除插入。

set 的使用场景：比如对手机游戏的个人得分记录的存储，存储要求从高分到低分的顺序排列。

map 的使用场景：比如按 ID 号存储十万个用户，想要快速要通过 ID 查找对应的用户。二叉树的查找效率，这时就体现出来了。如果是vector 容器，最坏的情况下可能要遍历完整个容器才能找到该用户。