【C++】标准模板库（STL）简要总结（通通随取随用！见识下什么是真正的cv工程师！）

重点强调：文章里面完全没有各种容器、迭代器等的实现原理，仅仅是对各类容器的代码总结，要想了解具体容器介绍和实现原理，可以查阅其他文章~~

文章分享的是STL里常用的一些声明和方法，都是可以安全食用直接cv的，可能有些没有整理出来，详情请见STL的官方文档~~

vector (动态数组)

声明方面： 

vector<type> a;//（定义容器向量a，容量为动态大小，类型为type） 

vector<type> a(x);//（定义容器向量a，容量为x，类型为type）

vector<type> a(b);//（定义类型为type的容器向量a，b为另一类型为type的容器向量，用b向量给a向量赋值）

vector<type> a(b.begin()+x,b.begin+y);//（b为另一类型为type的容器向量,将向量b从下标x到y-1的所有元素赋值给a，容器向量a为type类型）

vector<type> a(b+x,b+y);//（从数组中切片赋值，将数组b从下标x到y-1的所有元素赋值给容器向量a）

操作方面：  （标识往下标递减的方向为后，往下标递增的方向为前）

a.assign(b.begin(),b.begin()+x);//（b为向量，将b向量的下标从0到x-1的所有元素赋值给a向量）

a.assign(x,y);//（把a向量重置，再把x个值为y的元素插入a中）

a.back();//（返回a向量中下标为0的元素）

a.front();//（返回a向量中下标最大的元素）

a[x];//（返回a向量的下标为x的元素,当且仅当a向量存在）

a.clear();//（a向量重置）

a.empty();//（判断a向量是否为空，空则返回true，非空则返回false）

a.pop_back();//（删除a向量下标最大的元素）

a.erase(a.begin()+x,a.begin()+y);//（从a向量中删除下标从x到y-1的元素）

a.push_back(x);//（在a向量当前最大下标的元素后插入一个值为x的元素）

a.insert(a.begin()+x,y);//（在a向量下标为x的元素替换成y）

a.insert(a.begin()+x,y,z);//（在a向量下标为x的元素位置插入y个数，其值都为z）

a.insert(a.begin()+x,b+y,b+z);//（b必须为数组，在a向量下标为x的元素位置插入从b的下标为y到z-1的所有元素） 

a.size();//（返回a向量中元素的个数） 

a.capacity();//（返回a向量在内存中总共可以容纳的元素个数）

a.resize(x);//（将a向量的大小调整为x，当前大小比x大则从下标最大元素向后删，小则从下标最大元素向前补，补值为随机值）

a.resize(x,y);//（将a向量的大小调整为x，当前大小比x大则从下标最大元素向后删，小则从下标最大元素向前补，补值为y） 

a.reserve(x);//（将a向量的大小扩充至x）

a.swap(b);//（b为向量，将a向量中的所有元素和b向量中的所有元素整体交换）

a==b;//（b为向量，分别从a向量和b向量下标为0的元素开始依次比较大小，如果所有元素完全相等（与向量大小无关，判定随机值比任何数都要小），返回1，否则返回0）

a!=b;//（与上述返回值相反） 

a>=b;a>b;a<=b;a<b;//（b为向量，分别从a向量和b向量下标为0的元素开始依次比较大小，如果所有元素都满足比较运算符关系（与向量大小无关，判定随机值比任何数都要小），返回1，否则返回0） 

 string（字符串）

声明方面：（s代表string类的对象，ch代表char*类型字符串，c代表单个字符）

string str;//（创建一个空的字符串） 

string str(s);//（s是string类的对象，用s初始化另一个string类的对象） 

string str(ch);//（ch是char*类型字符串，用ch初始化str） 

string str(n,c);//（使用n个字符c初始化） 

操作方面：  （标识往下标递减的方向为后，往下标递增的方向为前）

str=ch;//（ch是char*类型字符串，赋值给当前string类的对象） 

str=s;//（把string类的对象s赋给当前string类的对象） 

str=c;//（把字符c赋值给当前string类的对象） 

str.assign(ch);//（把char*类型字符串ch赋给当前string类的对象） 

str.assign(ch,n);//（把char*类型字符串ch的前n个字符赋给当前string类的对象）

str.assign(s);//（把string对象s赋给当前string类的对象） 

str.assign(n,c);//（用n个字符c赋给当前string类的对象） 

str.assign(s,start,n);//（将string类的对象s从start开始n个字符赋值给当前string类的对象） 

str[n];//（通过[]方式取字符） 

str.at(n);//（通过at方法获取字符） 

str+=s;//（重载+=操作符） 

str+=ch;（重载+=操作符） 

str+=c;//（重载+=操作符） 

str.append(ch);//（把字符串s连接到当前string类的对象结尾） 

str.append(ch,n);//（把字符串s的前n个字符连接到当前string类的对象结尾） 

str.append(s);//（同operator+=()） 

str.append(s,start,n);//（把string类的对象s中从start开始的n个字符连接到当前string类的对象结尾） 

str.append(n,c);//（在当前string类的对象结尾添加n个字符c） 

str.find(s,0);//（查找s在string类的对象str中第一次出现位置,从start开始查找） 

str.find(ch,0);//（查找ch在string类的对象str中第一次出现位置,从start开始查找） 

str.find(ch,start,n);//（从start位置查找ch的前n个字符第一次位置） 

str.find(c,0);//（查找字符c第一次出现位置） 

！！！下面四个rfind函数注意了：与find不同，rfind是从所指定的位置向后查找，但返回的下标仍然是前向下标。

str.rfind(s,start);//（查找s最后一次位置,从start开始查找） 

str.rfind(ch,start);//（查找ch最后一次出现位置,从start开始查找） 

str.rfind(ch,start,n);//（从start查找ch的前n个字符最后一次位置） 

str.rfind(c,0);//（查找字符c最后一次出现位置） 

str.replace(start,n,s);//（替换从start开始n个字符为string类的对象s） 

str.replace(start,n,ch);//（替换从start开始的n个字符为字符串ch） 

str.compare(s);//（与string类的对象s比较） 

str.compare(ch);//（与字符串ch比较） 

str.substr(start,n);//（返回start开始的n个字符组成的字符串） 

str.insert(start,ch);//（插入字符串ch） 

str.insert(start,s);//（插入string类的对象s） 

str.insert(start,n,c);//（在start上插入n个字符c） 

str.erase(start,n);//（删除从start开始的n个字符） 

const char* a=s.c_str();//（把string类的对象s强转为char*型字符串并赋值给a） 

string s(a);//（把char*类型的字符串a强转为string类的对象并赋值给s） 

(int*)s.c_str();//（返回string类的对象s在内存中的地址） 

deque（前后开口的动态数组）

声明方面：

deque<type> d;//（定义deque容器向量d，容量为动态大小，类型为type）

deque<type> d(beg,end);//（构造函数将[beg, end)区间中的元素拷贝给本身） 

deque<type> d(n,elem);//（构造函数将n个elem拷贝给本身） 

deque<type> d(de);//（拷贝构造函数，将de拷贝给d） 

操作方面：

d.assign(beg, end);//（将[beg, end)区间中的数据拷贝赋值给本身） 

d.assign(n, elem);//（将n个elem拷贝赋值给本身） 

d=de;//（重载等号操作符）

d.swap(de);//（将de与本身的元素互换） 

d.size();//（返回容器中元素的个数） 

d.empty();//（判断容器是否为空） 

d.resize(num);//（重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除） 

d.resize(num, elem);//（重新指定容器的长度为num,若容器变长，则以elem值填充新位置,如果容器变短，则末尾超出容器长度的元素被删除。） 

d.push_back(elem);//（在容器尾部添加一个数据） 

d.push_front(elem);//（在容器头部插入一个数据） 

d.pop_back();//（删除容器最后一个数据） 

d.pop_front();//（删除容器第一个数据） 

d.at(idx);//（返回索引idx所指的数据，如果idx越界，抛出out_of_range） 

d[idx];//（返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错） 

d.front();//（返回第一个数据） 

d.back();//（返回最后一个数据） 

d.insert(pos,elem);//（在pos位置插入一个elem元素的拷贝，返回新数据的位置地址） 

d.insert(pos,n,elem);//（在pos位置插入n个elem数据，无返回值） 

d.insert(pos,beg,end);//（在pos位置插入[beg,end)区间的数据，无返回值） 

d.clear();//（移除容器的所有数据） 

d.erase(beg,end);//（删除[beg,end)区间的数据，返回下一个数据的位置地址） 

d.erase(pos);//（删除pos位置的数据，返回下一个数据的位置地址） 

queue（队列）

声明方面：

queue<type> q;//（queue采用模板类实现，queue对象的默认构造形式）

queue<type> q(que);//（拷贝构造函数）

操作方面： 

q.push(elem);//（往队尾添加元素） 

q.pop();//（从队头移除第一个元素） 

q.back();//（返回最后一个元素） 

q.front();//（返回第一个元素） 

q=que;//（重载等号操作符） 

q.empty();（判断队列是否为空） 

q.size();//（返回队列的大小） 

stack（栈）

声明方面：

stack<type> s;//（stack采用模板类实现， stack对象的默认构造形式） 

stack<type> s(stk);（拷贝构造函数）

 操作方面： 

s=stk;//（重载等号操作符） 

s.push(elem);//（向栈顶添加元素）

s.pop();//（从栈顶移除第一个元素） 

s.top();//（返回栈顶元素） 

s.empty();//（判断堆栈是否为空） 

s.size();//（返回堆栈的大小）

list （链表）

声明方面：

list<type> lstT;//（list采用采用模板类实现,对象的默认构造形式）

操作方面：

lstT.list(beg,end);//（构造函数将[beg, end)区间中的元素拷贝给本身） 

lstT.list(n,elem);//（构造函数将n个elem拷贝给本身） 

lstT.list(lst);//（拷贝构造函数） 

lstT.push_back(elem);//（在容器尾部加入一个元素） 

lstT.pop_back();//（删除容器中最后一个元素） 

lstT.push_front(elem);//（在容器开头插入一个元素） 

lstT.pop_front();//（从容器开头移除第一个元素） 

lstT.insert(pos,elem);//（在pos位置插elem元素的拷贝，返回新数据的位置） 

lstT.insert(pos,n,elem);//（在pos位置插入n个elem数据，无返回值） 

lstT.insert(pos,beg,end);//（在pos位置插入[beg,end)区间的数据，无返回值） 

lstT.clear();//（移除容器的所有数据） 

lstT.erase(beg,end);//（删除[beg,end)区间的数据，返回下一个数据的位置） 

lstT.erase(pos);//（删除pos位置的数据，返回下一个数据的位置） 

lstT.remove(elem);//（删除容器中所有与elem值匹配的元素） 

lstT.size();//（返回容器中元素的个数） 

lstT.empty();//（判断容器是否为空） 

lstT.resize(num);//（重新指定容器的大小为num，若容器变长，则以默认值填充新位置，如果容器变短，则末尾超出容器长度的元素被删除） 

lstT.resize(num, elem);//（重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除） 

lstT.assign(beg, end);//（将[beg, end)区间中的数据拷贝赋值给本身） 

lstT.assign(n, elem);//（将n个elem拷贝赋值给本身） 

lstT=lst;//（重载等号操作符） 

lstT.swap(lst);//（将lst与本身的元素互换） 

lstT.front();//（返回第一个元素） 

lstT.back();//（返回最后一个元素） 

lstT.reverse();//（反转链表，比如lstT包含1,3,5元素，运行此方法后，lst就包含5,3,1元素） 

lstT.sort();//（list排序） 

set

声明方面：

set<type> st;//（set默认构造函数）

set<type> st(s);//(拷贝构造函数)

操作方面：

st=s;//（等号赋值）

st.swap(s);//(交换两个集合容器)

st.size();//(返回容器中元素的数目)

st.insert(elem);//(在容器中插入元素)

st.clear();//(清除所有元素)

st.erase(pos);//(删除pos迭代器所指的元素，返回下一个元素的迭代器)

st.erase(start, end);//(删除区间[start,end)的所有元素 ，返回下一个元素的迭代器)

st.find(key);//(查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回st.end())

st.count(key);//(查找键key的元素个数)

st.lower_bound(elem);//（返回第一个键值大于或等于elem元素的迭代器）

st.upper_bound(elem);//(返回第一个键值大于elem元素的迭代器)

st.equal_range(elem);//(返回容器中键值与elem相等的上下限的两个迭代器)

 multiset

由于multiset特性及用法和set完全相同，唯一的差别在于它允许键值重复，因此用法完全和set相同，故不再过多赘述。

pair（对组）

声明方面：

pair<type1,type2> p(type1& t1,type2& t2);//(构造一个对组，第一元素为type1类型，第二元素是type2类型)

pair<type1, type2> p=make_pair(type1 t1,type2 t2);//(构造p对组，第一元素是type1类型的t1，第二元素是type2类型的t2)

pair<type1, type2> p1=p2;//(赋值构造p1,p2的元素类型和次序要求与p1相同)

操作方面：

p1.first;//（访问对组p的第一元素）

p.second;//（访问对组p的第二元素）

map

声明方面：

map<type1, type2> mp;//（map默认构造函数） 

map<type1,type2> mp(m);//(拷贝构造函数，m的元素类型和次序要求和mp一致)

操作方面：

mp=m;//(重载等号操作符)

mp.swap(m);//(交换两个集合容器)

mp.size();//(返回容器中元素的数目)

mp.empty();//(判断容器是否为空)

mp.insert(pair<type1, type2>(type1 t1, type2 t2));//(通过pair方式插入对象)

mp.inset(make_pair(type1 t1, type2 t2));//(用make_pair方法的方式插入对象)

mp.insert(map<type1, type2>::value_type(type1 t1, type2 t2));//（通过value_type的方式插入对象）

mp[idx] = elem;//(通过数组的方式插入值)

mp.clear();//(删除所有元素)

mp.erase(pos);//(删除pos迭代器所指的元素，返回下一个元素的迭代器)

mp.erase(start,end);//(删除区间[beg,end)的所有元素，返回下一个元素的迭代器)

mp.erase(elem);//(删除容器中键值为elem的对组)

mp.find(key);//(查找键key是否存在,若存在，返回该键的元素的迭代器;若不存在，返回mp.end())

mp.count(elem);//（返回容器中键key为elem的对组个数。对map来说，要么是0，要么是1。对multimap来说，值可能大于1）

mp.lower_bound(elem);//（返回第一个键值大于或等于elem的迭代器）

mp.upper_bound(elem);//(返回第一个键值大于elem元素的迭代器)

mp.equal_range(elem);//(返回容器中键值与elem相等的上下限的两个迭代器)

 

multimap

与multiset和set之间的区别一样，multimap和map的操作类似，唯一区别multimap键值可重复，这里就不再过多赘述。

嘿，内容到这里就结束啦！觉得有用的话就点点赞，加加收藏，文章内容并非完全原创，借鉴了各种书籍和文章，希望这段总结对你的学习有所帮助！