[学习笔记-C++篇]day9 STL教程

努力时毫不质疑，结束时绝不留恋。
更新计划了，9+1，第10天的教程会同步更新
感谢大佬几款优秀的支持C、C++在线编译器

---

stage1——10天入门阶段

教程网站：C++ 教程、C++ STL 教程
在线编译器：compile c++ gcc online
刷题网站：阶段1第一关：基本数据类型

day9 planA
教程4，刷题3
教程完成度100%，刷题完成度0%
主要原因：得调休

---

STL（标准模板库）含有通用模板类和函数。

C++标准模板库包含：容器、算法、迭代器。

1）容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如
deque、list、vector、map 。
2）算法作用于容器。它们提供了执行各种操作的方式，包括对容器内容执行初始化、排序、搜索和转换等操作。
3）迭代器用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。

注意，每种容器使用的时候都需要加上对应的头文件，比如vector、stack。

1. 向量&数组

参考C++ vector 容器浅析

向量Vector是一个封装了动态大小数组的顺序容器Sequence Container 。
向量和数组相似，但是可以自动处理内存。

具有3个特性：

1.顺序序列
顺序容器中的元素按照严格的线性顺序排序。可以通过元素在序列中的位置访问对应的元素。

2.动态数组
支持对序列中的任意元素进行快速直接访问，甚至可以通过指针算术进行该操作。提供了在序列末尾相对快速地添加/删除元素的操作。

3.能够感知内存分配器的（Allocator-aware）
容器使用一个内存分配器对象来动态地处理它的存储需求。

向量Vector函数汇总： 。

1.构造
vector():创建一个空vector
//vecotr<int> p;
vector(int nSize):创建一个vector,元素个数为nSize
//vector<int> p(5);
vector(int nSize,const t& t):创建一个vector，元素个数为nSize,且值均为t
//vector<int> p(5,3);
vector(const vector&):复制构造函数
//vector<int> or;
//vector<int> p(or);
vector(begin,end):复制[begin,end)区间内另一个数组的元素到vector中
//vector<int> or;
//vector<int> p(or.begin(),or.end());
vector<int> p{1,2,3};直接赋值

2.增加
void push_back(const T& x):向量尾部增加一个元素X
//vector<int> p;
//int a=5;
//p.push_back(a);
iterator insert(iterator it,const T& x):向量中迭代器指向元素前增加一个元素x
//注意！！！！迭代器是一个指针
iterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素x
iterator insert(iterator it,const_iterator first,const_iterator last):向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据

3.删除函数
iterator erase(iterator it):删除向量中迭代器指向元素
iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
void pop_back():删除向量中最后一个元素
void clear():清空向量中所有元素

4.遍历函数
reference at(int pos):返回pos位置元素的引用
reference front():返回首元素的引用
reference back():返回尾元素的引用
iterator begin():返回向量头指针，指向第一个元素
iterator end():返回向量尾指针，指向向量最后一个元素的下一个位置
reverse_iterator rbegin():反向迭代器，指向最后一个元素
reverse_iterator rend():反向迭代器，指向第一个元素之前的位置

5.判断函数
bool empty() const:判断向量是否为空，若为空，则向量中无元素

6.大小函数
int size() const:返回向量中元素的个数
int capacity() const:返回当前向量所能容纳的最大元素值
int max_size() const:返回最大可允许的vector元素数量值

7.其他
void swap(vector&):交换两个同类型向量的数据
void assign(int n,const T& x):设置向量中前n个元素的值为x
//可用于初始化
void assign(const_iterator first,const_iterator last):向量中[first,last)中元素设置成当前向量元素
//eg.s.assign(str.begin(),str.end()-1);
InputIteratorf ind_first_of(beg,end,sbeg,send);//返回同时在区间[beg,end)和[sbeg,send)出现的第一个元素位置的迭代器，可以赋值给it，找不到返回-1

参考C++STL算法篇find_first_of搜寻某元素第一次出现算法。

向量Vector常用函数示例：
·vector<int> obj;
·obj.push_back(3);//输入
·obj.pop_back();//删除最后一个元素
·obj.clear();//清空
·sort(obj.begin(),obj.end());//排序，默认升序；sort用<algorithm>头文件
·reverse(obj.begin(),obj.end());//翻转向量，结合sort可以变为降序排列。注意，这是一个void函数
·vector<int>::iterator it;//声明一个迭代器，来访问vector容器，作用：遍历或者指向vector容器的元素
·it=obj.begin();//取起始位置指针
·it!=obj.end();//常用作遍历的判断条件，end()是最后一个单元+1的指针
·int a=*it;//取出迭代器指针指向的值
·vector<vector<int>> obj(N);//定义一个二维数组，行数为N，注意这里用的是()而不是[]，一般数组int a[10]采用[]
·obj.size();//用于获得向量中元素数目，但在二维数组中表示行数
·obj[i].resize(M);//结合上上一句指令，用于给二维数组每行循环初始化，生成N * M维数组，值为0
·cout<<obj[i][j];//输出二维数组元素
·vector<vector<int> > obj(N, vector<int>(M));//直接定义N * M维（二维）数组，注意这里列数不能直接用M，而是要像分别定义一样用vector<int>(M)
·obj[i][j]=3;//直接给二维数组赋值
·return obj;//二维数组作为函数返回值，直接返回数组名
·int num=count(obj.begin(),obj.end(),0);//查找向量中元素0的个数
·vector<int>::iterator it=find(obj.begin(),obj.end(),0);//获取元素0的地址，可能不止一个地址，但这里只取一个，所以一般结合循环使用，可以参考day11的第5题
·obj.erase(it);//删除迭代器指向的元素
·vector<int> cp(obj.size(),0); //先定义一个和nums大小相同，元素均为0的向量
·cp.swap(nums);//交换2个向量
·obj.insert(it,3);//在迭代器it所指向位置开始，插入3

实际例子：

#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
   // 创建一个向量存储 int
   vector<int> vec; 
   int i;
 
   // 显示 vec 的原始大小
   cout << "vector size = " << vec.size() << endl;
 
   // 推入 5 个值到向量中
   for(i = 0; i < 5; i++){
      vec.push_back(i);
   }
 
   // 显示 vec 扩展后的大小
   cout << "extended vector size = " << vec.size() << endl;
 
   // 访问向量中的 5 个值
   for(i = 0; i < 5; i++){
      cout << "value of vec [" << i << "] = " << vec[i] << endl;
   }
 
   // 使用迭代器 iterator 访问值
   vector<int>::iterator v = vec.begin();
   while( v != vec.end()) {
      cout << "value of v = " << *v << endl;
      v++;
   }
 
   return 0;
}

此外， vector<string>也是用得较多的字符串数组方式。
参考vector初始化的几种方式

1.声明
# vector<string> str(10);//第1种就是先声明数组长度，注意！！！要用()，一般只有初始化的时候才会用{}说明元素内容
# str[0]="abc";//对每个元素赋值就和string一样

vecor<string> str;//第2种不说明数组长度
# str.push_back("abc");//赋值的时候和一般数组相同

# string s[]={"abc","ef"};//第3种，用构造函数
# vector<string> str(s,s+2);//这里的参数应该是地址 

2. 字符串&字符串数组

主要整理string常用函数。
参考c++中的string常用函数用法总结、C++string中用于查找的find系列函数浅析、c++内置函数实现字符串翻转（reverse，strrev，string 构造函数）

其实有相当一部分内容和vector是一样的。但有一些出入，用#标注了一下，实际使用不加#。
常用操作整理：

1.声明
#include <string>
using namespace std;
string s;//声明空字符串
string str;string s(str);//拷贝构造
string s(str,start);//拷贝str中start开始的字符
string s(str,start,len);//拷贝str中start开始长len的字符
string s(cstr);//把c字符串赋值给s
string s(cstr,clen);//把c字符串前clen个字符串赋值给s
string s(num,c);//构建含有num个c字符的字符串
//eg.string s(5,c);
string s(begin,end);//将beg开始到end前1个之间的字符赋值给s
//eg.string str("hello");string s(str.begin(),str.end());
//别的资料说是beg，但是测试不可以，可能是我用的不对，但begin是可以的
# string s("abc");//直接赋值，注意！！！和vector<int>不同
string s="abc";

2.赋值、string转vector<char>
（用的时候不能和声明一起用，要重新赋值才可以）
s.assign(str);//拷贝赋值
s.assign(str,index,num);//把str从第index索引处开始的num个字符赋值给s
//eg.string str="hello";string s;s.assign(str,0，3);
# s.assign(str,index,string::npos);//把str从index开始到结束赋值给s，注意！！！，一般s.assign(str,index);默认是将从第index索引处开始后所有元素赋值给s
s.assign(num,c);//和前面一样，把num个c字符赋值给s
s.assign("abc");//直接赋值
s.assign("abc",4);//把"abc"字符的前4个字符赋值给s，当然超出"abc"的时候，多的一位字符是'\0'
此外，assign还可以用于把string转vector<char>
string s = "what";
vector <char> vc;
vc.resize(s.size());
vc.assign(s.begin(),s.end());

3.增加、插入
s.push_back('a');//在s后面增加字符s
s=s1+s2;//字符可以直接用加号相加
s+="a";//s最后加一个字符串
s+='a';//s最后加一个字符
# s.insert(3,"abc");//在s的第3个索引处插入字符串"abc"，注意！！！这种形式不支持单个字符插入
insert(size_type index,size_type num,chart c);//在index索引处插入num个字符c
//eg.insert((string::size_type)1,1,'c');
insert(iterator pos,size_type num,chart c);//iterator是char*型，

4.删除、清空
s="";//清空，也可以在初始化的时候用，建一个空字符串
# s.erase();//清空，默认从头删除，注意！！！这里和vector不同
s.erase(index);//删除index索引开始之后的内容
//eg.string s="abd";s.erase(2);最后s为"ab"
s.erase(index,num);//删除index索引开始num个字符
//eg.string s="helfo";s.erase(1,2);最后s为hfo
# s.erase(std::remove(s.begin(), s.end(), 'a'), s.end());
注意！！！用于C++从string中删除所有的某个特定字符
//remove头文件algorithm
s.clear();//清空

5.提取子串
s.substr();//提取s所有字符
//eg.string s;string ss;ss=s.substr();
s.substr(index);//提取s从index索引开始之后的所有字符串
//eg.ss=s.substr(3);
s.substr(index,num);//提取s从index索引开始之后的num个字符串
//eg.ss=s.substr(2,3);

6.输入、输出
cin >> s;
s=getline(istream &in,string &s);//从输入流in读取字符串到s，遇到换行符'\n'或者文件尾结束
cout << s << endl;//可以直接用字符串名称输出

7.查找
(函数里的形参pos都给了默认索引0，使用的时候根据需要给参数；找不到返回-1)
int find(char c, int pos = 0) const;//从pos开始查找字符c在当前字符串的位置
# int find(const char *s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
int find(const char *s, int pos, int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置
# int find(const string &s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
//eg. int a=s.find('a')从第0位查找字符a出现的位置
# int find_first_of(char c, int pos = 0) const;//从pos开始查找字符c第一次出现的位置
int find_first_of(const char *s, int pos = 0) const;
int find_first_of(const char *s, int pos, int n) const;
int find_first_of(const string &s,int pos = 0) const;
//string st2("aabcbcabcbabcc");
//string str1("abc");
//cout << st2.find(str1, 2) << endl;

8.翻转
strrev(s);//翻转s，注意！！！头文件是cstring，但一般算法题不包含这个头文件
# reverse(s.begin(),s.end());//注意！！！头文件是algorithm

9.常用函数
s.size();//返回字符串长度
# s.length();//也是返回长度，注意！！！这个vector不能用
# s.empty();//判空，注意！！！返回值是bool类型
s.resize(int len,char c);//把s重置为长度len的字符串，不足的部分用字符c填充
//eg.string s("abc");s.resize(5,'w');
# s.replace(1,2,"ntern");//从索引1开始的2个替换成后面的字符串，注意！！！这里的第2个数字不是规定替换字符的长度，而是被替换的字符长度，可以用不同长度的字符串进行替换
//eg.s.replace(1,2,"ww");
# s.swap(string &str);//交换2个字符串内容，注意！！！这个函数没有返回值
//eg.string s("hello");string str("world");s.swap(str);
string::iterator//也可以用迭代器
string::const_iterator//不允许改变迭代的内容
s[i];//取字符串的第i个字符
s.at(index);//取字符串index索引处的字符

10.更改字符串中的值
举个例子：
for (auto &c : s)   // for every char in s (note: c is a reference)
    c = toupper(c); // c is a reference, so the assignment changes the char
in s
————————————————
原文链接：https://blog.csdn.net/wy1550365215/article/details/77417396
此外参考：https://blog.csdn.net/piaopiaopiaopiaopiao/article/details/39316255

这里用到：
for (auto &c:s)//此处c不需要定义，不需要声明，代表的是s中的字符，自动从s第一位开始循环
等同于：
for(auto it=s.begin();it<s.end();it++)
但是，加上&就会改变s中字符的值，如果不加&，就不会改变。

参考C++字符串数组
下面整理一下字符串数组的主要操作：

1.声明
string s[5];//声明字符串数组，包含5个字符串元素
# string s[2]={"hello","world"};//创建并初始化，注意！！！这里要用中括号

2.其他函数
s.size();//字符串数组返回行数，即有多少个字符串元素
s[i].length();//第i个字符串元素的长度
s[i][j];//字符串数组的第i个字符串的第j个字符

说明：
1）每个字符串元素长度可以不同
2）字符串数组的每一个元素存放一个字符串，而不是一个字符，这是字符串数组与字符数组的区别｡如果用字符数组存放字符串,一个元素只能存放一个字符,用一个一维字符数组存放一个字符串｡
3）每一个字符串元素中只包含字符串本身的字符而不包括\0｡

---

小对比1：初始化方式

1.初始化方式
vector<int> p{1,2,3};
vector<string> s(str,str+num);
string str("abc"); string str="abc";
string str[2]={"abc","ef"}; string str[]={"abc"};
deque<int> dq={1,2,3};
list<int> l{1,2,3}; list<int> l={1,2,3};
set<string> fruit{"orange", "apple", "mango", "peach", "grape"};
map<char, int> m1 = { {'a', 10}, {'b', 20}, {'c', 30} };

---

3. 栈stack

堆栈数据结构，最大的特点是先进后出。

template<class T, class Container = deque<T> > class stack;

T：参数指定容器适配器将保留的元素的类型。
Container：参数指定容器的内部对象，用于容纳堆栈的元素。

堆栈成员类型：

常用函数：

1.构造
stack<int> st; stack<string> st;
stack<int> sg=st;//直接赋值

2.插入、删除、输出
st.push(num);//将元素输入栈顶部
st.emplace(num);//说是在栈顶部元素上的栈中插入新元素，但是用起来和push差不多
st.pop();//删除顶部一个元素
st.top();//输出顶部元素，不删除

3.判断大小
st.size();//返回栈大小，即元素数目
st.empty();//判空

4.交换
stack<int> sg; stack<int> st;
sg.swap(st);

4.队列queue

采用先进先出技术。

template<class T, class Container = deque<T> > class queue;

成员类型：

常用函数：

1.构造
queue<int> q;
queue<int> qu=q;

2.输入输出、插入删除
q.front;//返回第1个元素
q.back;//返回最后一个元素
q.push(3);//在最后一个元素后插入新元素
q.emplace(3);//和push类似
q.pop();//删除front处的1个元素

3.判断大小
q.size();
q.empty();

4.交换
queue<int> q; queue<int> qu;
q.swap(qu);

5.双端队列deque

概括了队列数据结构，即可以从前端或后端的两端进行插入和删除。

deque<object_type> deque_name;

常见函数：
完整版参见C ++双端队列函数

1.构造
deque<int> de;
# deque<int> dq={1,2,3,4};//注意！！！和vector<int> v{1,2,3};还是有区别的
dp.assign(de.begin(),de.end());
dp.assign(num,int);//eg.dp.assign(3,2);初始化dp内容为2 2 2

2.插入、删除
dp.emplace(const_iterator position,value_type val);//eg. dp.emplace(dp.begin(),1);在指定位置插入元素
dp.insert(iterator pos, value_type val);//eg. dp.insert(dp.begin(),3);在指定位置插入元素
dp.insert(iterator pos, int n, value_type val);// dp.insert(dp,begin()+1,2,3);在指定位置插入n次元素val
dp.insert(iterator pos, InputIterator first,InputIterator last);//eg. dp.insert(dp.begin(),de.begin(),de.end());在指定位置插入另一个队列起始指针first到结束指针last之间的元素

dp.emplace_front(value_type val);//在队列前端插入元素
dp.push_front(value_type val);
dp.emplace_back(value_type val);//在队列后端插入元素
dp.push_back(value_type val);

dp.pop_front();//删除前端元素
dp.pop_back();//删除后端元素
# dp.erase(iterator pos);//删除指定位置的元素，注意！！！不是之后元素也删除，只删除当前指针指向的元素 eg. deque<string> dp={"abc","ed","fg"}; dp.erase(dp.begin()+1);结果dp中的内容为"abc" "fg"
dp.erase(iterator first,iterator last);//eg. dp.erase(dp.begin()+1,dp.begin()+2);删除指定位置之间的元素
dp.clear();//清空

3.判断大小、重设大小
dp.size();
dp.empty();
# dp.resize(int n);//eg. dp.resize(2);将dp重新设置为只有2个元素，那么之后的元素都会被删除
# dp.resize(int n,value_type val);//eg. deque<int> dp={1,2,3}; dp.resize(7,4); 将dp大小重新设置为n，不足的地方用val填充，则结果为1 2 3 4 4 4

4.访问元素
dp.at(index);//eg. dp.at(1);返回指定索引处的元素
dp.operator[] (index);//eg. dp.operator[](3);和上面一样，注意！！！超出索引范围返回0
dp.front();//访问前端元素
dp.back();//访问后端元素

5.交换
dp.swap(d);

6.列表list

list是连续的容器，而vector是非连续的容器，即list将元素存储在连续的存储器中，而vector存储在不连续的存储器中。

list克服了vector插入删除对元素移动的问题，支持双向。但遍历速度很慢，因为列表元素是按顺序访问的，而vector支持随机访问。

常用函数：
参见C ++列表函数

1.构造
list<int> l;
# list<int> l{1,2,3,4};//注意！！！，这里又和vector一样了
# list<int> l={1,2,3,4};//也可以像deque一样

2.插入删除
l.push_front();//eg. l.push_front(1);
l.push_back();//eg. l.push_back(2);
l.insert( iterator pos, const value_type value);//注意！！！和deque一样
l.insert( iterator pos, int n, const value_type value);
l.insert( iterator pos, InputIterator first, InputIterator last);

l.pop_front();
l.pop_back();

3.判断大小
l.size();
l.empty();

4.访问元素
l.front();
l.back();

5.其他操作
l.swap(ls);
# l.sort();//递增排序，无参数，注意！！！和vector不同
# l.reverse();//翻转，同样无参数
# l.merge(ls);//将ls列表和l合并，元素插入到l后
# l.merge(ls,compare);//compare为一个函数，比较函数，用于比较l和ls中的元素，如果第一个参数的值小于第二个参数，则返回true，否则返回false。
# 可用于增序合并2个列表
//eg.
#include <iostream>
#include<list>
using namespace std;
bool comparison(int first, int second)
{
    bool a;
    a=first<second;
    return (a);
}
int main()
{
  list<int> li={9,10,11};
  list<int> li1={5,6,7,15};
  li.merge(li1,comparison);
  for(list<int>::iterator itr=li.begin();itr!=li.end();++itr){
      std::cout << *itr <<" "<< std::endl;
  }  
  return 0;
}

------------------------output--------
5 6 7 9 10 11 15

7.集合set

集合是存储排序键的关联容器，每个键都是唯一的，可以插入或删除但不能更改。

语法：

template < class T,                             // set::key_type/value_type
           class Compare = less<T>,        // set::key_compare/value_compare
           class Alloc = allocator<T>         // set::allocator_type
           > class set;

1. T：存储在容器集中的元素类型。
2. Compare：一个比较类，它接受两个具有相同bool类型的参数并返回一个值。此参数是可选的，二进制谓词less 是默认值。
3. Alloc：分配器对象的类型，用于定义存储分配模型。

常用函数：

1.构造
set<char> st;
# int evens[] = {2,4,6,8,10}; set<int> myset (evens, evens+5);//范围构造函数
set<int> s1; s1.insert(5);//默认构造
set<int> s2(s1);//复制构造
set<int> s2(move(s1));//拷贝构造，直接移动s1
set<string> fruit {"orange", "apple", "mango", "peach", "grape"}; //初始化构造，注意！！！没有=

2.迭代器
set<string>::iterator it;
st.begin();
st.end();

3.判断大小
st.size();
st.empty();

4.插入删除
st.insert(2);//直接插入元素
myset.erase (*it);//删除迭代器指向的元素，注意这里用的都要是值
st.erase(2);
it = m.erase(it);//也可以用指针
myset.erase ( myset.begin () ,  myset.end () );//范围删除
st.clear();//清空

5.查找
it=myset.find('b');//仍旧是用迭代器
st.count(2);//查找并统计元素2的数目，如果没有该元素，返回值为0

6.交换
st.swap(sst);
swap(st,sst);

8.map容器

可用于具有对应关联关系的2种类型量中。

map是存储排序的键值对的关联容器，其中每个键都是唯一的，可以插入或删除，但不能更改。但是与键关联的值可以更改。

例如：一个员工map容器，其中员工ID是键，姓名是值，则可以表示为：

语法：

template < class Key,                     //map::key_type
           class T,                 //map::mapped_type
           class Compare = less,         //map::key_compare
           class Alloc = allocator<pair>    //map::allocator_type
           > class map;

1. key：要存储在map中的键的数据类型。
2. T：要存储在map中的值的数据类型。
3. compare：一个比较类，它接受两个bool类型相同的参数，并返回一个值。此参数是可选的，二进制谓词less <“ key”>是默认值。
4. alloc：分配器对象的类型。此参数是可选的，默认值为分配器。

创建：

typedef pair<const Key, T> value_type;

上面的语句将用于创建一个键类型为Key类型,且value值类型为T的map。重要的一点是，map的键和相应的值始终成对插入，您不能在map中仅插入键或仅插入值。

常用函数：

1.构造
map m;//什么类型都不声明
map<int int> m;//说明键和值的类型
# map<char, int> m1 = { {'a', 10}, {'b', 20}, {'c', 30} };//构造时初始化，注意要分组进行初始化
map<char, int> m1; m1 = { {'a', 10}, {'b', 20}, {'c', 30} };//分开赋值
map <int int> mp=m;//拷贝构造
# mp.insert(m.begin(),m.end());//拷贝构造
# map <int int> mp=move(m);//移动内容，这样被移动的map就会为空
# 注意！！！这里一个键+一个值是一个元素
# 还有一种构造法
typedef map<string, int> phoneMap;
string name;
int number;
phoneMap phone;
for(int i =0; i<3; i++)
{
    cin>> name;      // 获取键
    cin>> number;    // 获取值
    phone[name] = number;   //将值推入map
}

2.赋值
map Employees; Employees[101] = "Nikita";//通过键赋值
# map<char,int> m; m['a']=1;m['b']=2;

3.迭代器
# map<char,string> m; map<char,string>::iterator it=m.begin();//begin()函数用于返回指向map映射中第一个元素的迭代器。
通常结合for_each()进行循环遍历
for_each(m.begin(), m.end(),[](pair<string, int> element)// 从元素访问KEY
			string word = element.first;
			// 从元素访问VALUE。
			int count = element.second;
			cout<<word<<" = "<<count<<endl;
		});
m.begin();//返回指向map中第一个元素的迭代器。
m.end();//返回指向末尾的后1个迭代器。
# 这里一个指针对应一个元素（键+值）

4.判断大小
m.empty();
# m.size();//注意！！！，这里取的仍旧是元素

5.访问元素
# map<char,int> m; char ma=m.first;//获取一个键，注意！！！一般一个map有多个键，因此，这句指令通常结合for_each()
# int mb=m.second;//取一个值
# for (auto& x: mymap) {
    	cout << x.first << ": " << x.second << '\n';
  }//也可以用这样的方式迭代取
# map<int,int> m; map<int,int>::iterator it=m.begin(); int ma=it->first;//用迭代器取键
# int mb=it->second;//用迭代器取值
# int ma=m.begin()->first; int mb=m.begin()->second;//也可以用这样的迭代器取
# m['a'];//也可以直接用键去访问值
# m.at('a');//也可以这样用键访问

6.插入删除
# map<char,int> m; m.insert(pair<char, int>('d', 4));//默认在map尾部插入元素
# m.inset(m.begin(),pair<char,int>('c',3));//在指定位置插入元素
# m.insert({{4,"VB"}, {5, "Oracle"}});//直接插入多个元素，类似初始化的时候要用{{},{}}
# mymap.erase(mymap.begin());//删除指定位置的元素
m.clear();//清空
# map<char,int> m={{'a',1},{'b',2}}; m=map<char,int> ();//清空内容

7.交换
# map<char,int> m; map<char,int> mp; mp.swap(m);
swap(mp,m);//这样也可以的

8.查找
# map<char,int> m; auto it=m.find('a');//注意！！！这里it是迭代器，就是说在map中查找键为'a'的元素的迭代器指针，如果需要获得里面的键和值，仍旧需要用
it->first;it->second;
# 可以和循环结合使用
auto search = example.find(n);//可以用auto自动识别迭代器格式，也可以用map<char,int>::iterator it;声明一下
if (search != example.end()) {
    cout << n<<" 找到，值是 " << search->first << " = " << search->second << '\n';
} else {
    cout << n<<" 未找到\n";
}

---

小对比2：插入删除

2.插入删除
vector<int> p; p.push_back(3); p.pop_back();
string str; str.push_back('a'); str.erase(index,num);
stack<int> st; st.push(2); st.emplace(5); st.pop();
queue<int> q; q.push(3); q.emplace(3); q.pop();
deque<int> dq; dp.push_front(1); dp.push_back(2); dp.emplace(dp.begin(),3); dp.emplace_front(4); dp.emplace_back(5); dp.pop_front(); dp.pop_back(); dp.erase(iterator);
list<int> l; l.push_front(1); l.push_back(2); l.pop_front(); l.pop_back();