STL（Standard Template Library，标准模板库）
STL从广义上分为容器、算法、迭代器
共六大组件：
容器：各类数据结构，如vector、list、set、map
算法：如sort、find、copy、for_each
迭代器：连接容器与算法
仿函数：行为类似函数，可作为算法的某种策略
适配器：修饰容器或仿函数或迭代器接口
空间配置器：空间配置与管理
容器算法迭代器示例
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void Myprint(int val){
cout<<val<<endl;
}
void test(){
//创建一个vector容器，数组
vector<int> v;
//向容器中插入数据
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
//通过迭代器访问容器中数据
vector<int>::iterator itBegin=v.begin(); //v.begin()：起始迭代器，指向容器中第一个元素
vector<int>::iterator itEnd=v.end(); //v.end()：结束迭代器，指向容器中最后一个元素下一个位置
//第一种遍历
while(itBegin!=itEnd){
cout<<*itBegin<<endl;
itBegin++;
}
//第二种遍历
for(vector<int>::iterator it=v.begin();it!=v.end();it++){
cout<<*it<<endl;
}
//第三种遍历，要加algorithm头文件
for_each(v.begin(),v.end(),Myprint);
}
int main(){
test();
return 0;
}vector 中存放自定义数据类型
#include<iostream>
#include<vector>
#include<string>
using namespace std;
//vector容器中存放自定义数据类型
class Person{
public:
Person(string name,int age){
m_Name=name;
m_Age=age;
}
string m_Name;
int m_Age;
};
void test(){
vector<Person> vec;
Person p1("张三",10);
Person p2("李四",11);
Person p3("王五",12);
Person p4("赵柳",13);
//向容器中压入数据
vec.push_back(p1);
vec.push_back(p2);
vec.push_back(p3);
vec.push_back(p4);
for(vector<Person>::iterator it=vec.begin();it!=vec.end();it++){
cout<<"姓名为："<<it->m_Name<<" 年龄为："<<(*it).m_Age<<endl;
}
}
void test02(){
vector<Person*> v;
Person p8("张三",10);
Person p5("李四",11);
Person p6("王五",12);
Person p7("赵柳",13);
//向容器中压入数据
v.push_back(&p7);
v.push_back(&p6);
v.push_back(&p5);
v.push_back(&p8);
for(vector<Person*>::iterator it=v.begin();it!=v.end();it++){
cout<<"姓名为："<<(*it)->m_Name<<" 年龄为："<<(*(*it)).m_Age<<endl;
}
}
int main(){
test();
test02();
return 0;
}容器嵌套容器
#include<iostream>
#include<vector>
using namespace std;
//vector容器嵌套vector容器（相当于二维数组）
void test(){
vector<vector<int>>vec;
//创建小容器
vector<int>v1;
vector<int>v2;
vector<int>v3;
vector<int>v4;
//向小容器中压入数据
for(int i=0;i<4;i++){
v1.push_back(i+1);
v2.push_back(i+10);
v3.push_back(i+100);
v4.push_back(i+1000);
}
//将小容器压入大容器
vec.push_back(v1);
vec.push_back(v2);
vec.push_back(v3);
vec.push_back(v4);
//通过大容器遍历所有数据
for(vector<vector<int>>::iterator it=vec.begin();it!=vec.end();it++){
//注意此时 *it 就是一个容器vector<int>
for(vector<int>::itertor vit=(*it).begin();vit!=(*it).end();vit++){
cout<<*vit<<'\t';
}
cout<<endl;
}
}
int main(){
test();
return 0;
}1. string 容器
1.1 本质：c++风格字符串，本质上是一个类
char* 是一个指针
string类内封装了char* ，是一个char*型容器
1.2 构造函数
string(); //创建空字符串
string(const char*s); //使用字符串s初始化
string(const string& str) //使用一个string对象初始化另一个string对象（拷贝构造）
string(int n,char c) //使用n个字符c初始化
1.3 赋值操作
string& operator=(const char* s); //char*类型字符串 赋给当前字符串
string& operator=(const string& s); //把字符串s赋给当前字符串
string& operator=(char c); //字符c赋值给当前字符串
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赋给当前字符串
1.4 字符串拼接
string& operator+=(const char* str); //重载+=操作符
string& operator+=(const char c); //重载+=操作符
string& operator+=(const string& str); //重载+=操作符
string& append(const char*s) //把字符串s连接至当前字符串尾部
string& append(const char*s,int n) //把字符串s前n个字符连接至当前字符串尾部
string& append(const string& s) //同operator+=(const string& str)
string& append(const string& s,int pos,int n) //字符串s中从pos开始的前n个字符连接至字符串尾
/*示例*/
string str1="我";
str1+="爱学习";
str1+=':';
string str2="写代码编程";
str1+=str2;
string str3="I";
str3.append("love");
str3.append("c++ Emmmmmm",3);
str3.append(str2);
str3.append(str2,3,2); //注意参数二——从str2某位置开始（0为str2起始），参数三为字符个数1.5 查找与替换
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; //查找字符串str最后一次位置，从pos开始
int rfind(const char* s,int pos,int n)const; //查找s最后一次位置，从pos开始
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
string str1="abcdefgde";
int pos=str1.find("de",0); //从0号位开始查找str1中是否有"de"，并返回第一个"de"第一个字符下标；若无则返回-1
int rpos=str1.rfind("de"); //从str1右边向左边查找，并返回第一个"de"第一个字符下标；若无则返回-1
str1.replace(1,4,"aaaaa"); //从str1的1号位到4号位4个字符换成指定，注意即使指定多了一个，也均会插入1.6 字符串比较
按字符ASCII码对比，=返回0；>返回1；<返回-1
int compare(const string& s)const;
int compare(const char*s)const;
string str1="xello";
string sre2="hello";
if(str1.compare(str2)==0){
cout<<"str1=str2"<<endl;
}
else if(str1.compare(str2)>0){
cout<<"str1>str2"<<endl;
}
else cout<<"str1<str2"<<endl;1.7 字符串存取
char& opeerator[](int n); //通过[]方式取字符
char& at(int n); //通过at方式取字符
string str="hello";
for(int i=0;i<str.size();i++){
cout<<str[i];
cout<<str.at(i)<<endl;
}1.8 字符串插入与删除
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个字符
string str="hello";
str.insert(1,"111"); //在1号位插入"111"，即输出h111ello
str.erase(1,3); //从1号位起删除3个字符1.9 子串
string substr(int pos=0,int n=npos)const; //返回从pos开始的n个字符组成的字符串
string str="abcdef";
string str1=str.substr(1,3); //返回从1号位开始3个字符2. vector
2.1 基本概念
与数组类似，称单端数组。不同于数组是静态空间，vector可以动态扩展：并不是在原空间后接续新空间，而是找到一个更大的空间，将原数据拷贝新空间，释放原空间。vector迭代器支持随机访问
2.2 构造函数
vector<int>v1;
for(int i=0;i<10;i++){
v1.push_back(i);
}
vector<int>v2(v1.begin(),v2.begin());
vector<int>v3(10,100); // 10个100
vector<int>v4(v3);2.3 赋值操作
vector<int>v1;
vector<int>v2;
v2=v1;
vector<int>v3;
v3.assign(v1.begin(),v1.end()); //注意区间左开右闭
vector<int>v4;
v4.assign(10,100); //10个1002.4 容量大小
empty(); //判断容器是否为空:空，返回1
capacity(); //容器容量
size(); //返回容器元素个数
resize(int num); //重新指定容器长度为num，若变长则以默认值0填充新位置；若变短，则末尾超出容器长度的元素被删除
resize(int num,elem); //重新指定容器长度为num，若变长则以elem填充新位置；若变短，则末尾超出容器长度的元素被删除
2.5 插入与删除
pushu_back(ele); //尾部插入元素ele
pop_back(); //删除最后一个元素
insert(const_iterator pos,ele); //迭代器指向位置pos插入元素ele
insert(const_iterator pos,int count,ele); //迭代器指向位置pos插入count个元素ele
erase(const_iterator pos); //删除迭代器指向元素
erase(const_iterator start,const_iterator end); //删除迭代器从start到end间元素
clear(); //删除容器内所有元素
void print(const vector<int> &v){
for(vector<int>::const_iterator it=v.begin();it<v.end();it++){
//*it=100; //此句非法，因为有const修饰，*it不可修改
cout<<*it<<'\t';
}
cout<<endl;
}
void test(){
v1.push_back(10);
v1.push_back(20);
v1.push_back(30);
v1.push_back(40);
v1.push_back(50);
print(v1);
v1.pop_back();
print(v1);
v1.insert(v1.begin(),100); //在v1的最开始插入100
print(v1);
v1.erase(v1.begin());
print(v1);
v1.erase(v1.begin(),v1.begin()+2);
print(v1);
}2.6 数据存取
at(int index); //返回索引index所指的数据
operator[]; //返回索引所指元素
front(); //返回容器第一个元素
back(); //返回容器中最后一个元素
2.7 互换容器
实现两个容器元素互换
swap(vec); //将vec与本身元素互换
#inculde<iostream>
#inculde<vector>
using namespace std;
void test01(){
vector<int>v1;
for(int i=0;i<10;i++){
v1.push_back(i);
}
vector<int>v2;
for(int i=10;i>0;i--){
v2.push_back(i);
}
}
void test02(){
vector<int>v;
for(int i=0;i<100000;i++){
v1.push_back(i);
}
cout<<"v的容量为："<<v.capacity()<<endl;
cout<<"v的大小为："<<v.size()<<endl;
v.resize(3); //重新指定大小为3，但容量不变
vector<int>(v).swap(v); /*利用swap收缩内存，首先vector<int>(v)构造一个匿名对象，该匿名对象大小为当前v大小，再与v互换；互换后匿名对象被回收*/
cout<<"v的容量为："<<v.capacity()<<endl;
cout<<"v的大小为："<<v.size()<<endl;
}
void print(vector<int> &v){
for(vector<int>::iterator it=v.begin();it<v.end();it++){
cout<<*it<<'\t';
}
cout<<endl;
}
int main(){
test01();
test02();
print(v1);
print(v2);
v1.swap(v2);
print(v1);
print(v2);
return 0;
}2.8 预留空间
减少vector在动态扩展容量时的扩展次数
reserve(int len); //容器预留len个元素长度，预留位置不初始化，元素不可访问
#inculde<iostream>
#inculde<vector>
using namespace std;
void test01(){
vector<int>v;
int num;
int *p=NULL;
// v.reserve(100000);
for(int i=0;i<100000;i++){
v.push_back(i);
if(p!=&v[0]){
p=&v[0];
num++;
}
}
cout<<"共开辟了"<<num<<"次内存"<<endl;
}3.deque容器
3.1 基本概念
双端数组，可对头尾进行插入删除操作。迭代器支持随机访问
与vector区别：
vector对头部插入删除效率低
deque对头部插入删除快
vector访问元素比deque快
3.2 构造函数（与vector类似）
deque<T>deq; //默认构造
deque<T>(beg,end); //将（beb,end)区间元素拷贝给自身
deque<T>(n,elem); //将n个elem拷贝给自身
deque<T>(const deque &deq); //拷贝构造
3.2 赋值操作
deque& operator=(const deque &deq); //重载等号操作符
assign(beg,end); //(beg,end)区间内元素拷贝给自己
assign(n,elem) //n个elem拷贝给自己
3.3大小操作
empty(); //判断容器是否为空:空，返回1
size(); //返回容器元素个数
resize(int num); //重新指定容器长度为num，若变长则以默认值0填充新位置；若变短，则末尾超出容器长度的元素被删除
resize(int num,elem); //重新指定容器长度为num，若变长则以elem填充新位置；若变短，则末尾超出容器长度的元素被删除
3.4插入与删除
两端插入操作：
push_back(elem);
push_front(elem);
pop_back();
pop_front();
指定位置操作：
insert(pos,elem);
insert(pos,n,elem);
insert(pos,beg,end); //在pos位置插入[beg,end)区间数据
clear();
erase(beg,end); //删除[beg,end)数据，返回下一个数据位置
erase(pos); //删除pos位置的数据返回下一个数据位置
注意：插入与删除提供的位置是迭代器！
3.5数据存取
与vector一样
3.6 排序
算法：sort(interstor beg,iterator end);
#include<iostrem>
#include<deque。
using namespace std;
#include<algoritm>
void print(const deque<int> &deq){
for(deque<int>::const_iterator it=deq.begin();it!=deq.end();it++){
cout<<*it<<'\t';
}
cout<<endl;
}
void test(){
deque<int>d;
d.push_back(20);
d.push_back(10);
d.push_back(30);
d.push_front(200);
d.push_front(300);
print(d);
sort(d.begin(),d.end()); //默认排序为升序排序
print(d);
}
void main(){
test();
}4. stack容器
特点：先进后出，不可遍历
4.1 常用函数接口
构造函数：
stack<T> stk;
stack(const stack &stk);
赋值函数：
stack& operator=(const stack &stk);
数据存取函数：
push(elem);
pop(); //从栈顶移除第一个元素
top(); //返回栈顶元素
大小操作函数：
empty();
size();
5. queue 容器
5.1 基本概念
先进先出，从一端新增，从另一端移除。只有头尾才可被外界使用，不允许遍历
5.2 常用接口
构造函数：
queue<T> que;
queue(const queue &que);
赋值函数：
queue& operator=(const queue &que);
数据存取函数：
push(elem);
pop(); //从栈顶移除第一个元素
back(); //返回最后一个元素
front(); //返回第一个元素
大小操作函数：
empty();
size();
6. list 容器
6.1 基本概念
功能：将数据进行链式存储
链表（list）是一种物理存储单元上非连续存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现
组成：链表=由一系列节点组成
节点：存储元素的数据域 以及 存储下一个节点位置的指针域
STL中链表是双向循环链表，指针域会记录上一个与下一个节点位置。链表list中的迭代器只支持前移后移
优点：可对任意位置快速插入与删除；不会造成内存浪费与溢出；插入删除操作不会造成迭代器失效
缺点：容器的遍历速度慢于数组；占用的空间大于数组
6.2 构造函数
list<T> lst;
list(beg,end);
list(n,elem);
list(const list &lst);
6.3 赋值与交换
assign (beg,end);
assign(n,elem);
list& operator=(const list &lst); //重载 = 运算符
swap(lst); //将lst与本身元素互换
6.4 大小操作
empty(); //判断容器是否为空:空，返回1
size(); //返回容器元素个数
resize(int num); //重新指定容器长度为num，若变长则以默认值0填充新位置；若变短，则末尾超出容器长度的元素被删除
resize(int num,elem); //重新指定容器长度为num，若变长则以elem填充新位置；若变短，则末尾超出容器长度的元素被删除
6.5 插入与删除
push_back(elem);
pop_back();
push_front(elem);
pop_front();
insert(pos,elem) //在pos位置插入元素elem的拷贝，并返回新数据位置
insert(pos,n,elem);
insert(pos,beg,end);
clear();
erase(beg,end); //删除[beg,end)区间内数据，返回下一个数据位置
erase(pos); //删除pos位置数据，返回下一个数据位置
remove(elem); //删除容器中所有与elem元素值匹配的元素
6.6 数据存取
front();
back();
6.7 反转与排序
reverse(); //反转链表
sort(); //链表排序（升序）
注意：所有不支持随机访问的迭代器的容器不可以用标准算法，如sort(L1.begin(),L1.end());会报错。这种容器内部会提供对应的算法，L1.sort();即可
#include<iostream>
#include<list>
using nmespace std;
void print(const list<int> &l){
for(list<int>::cons_iterator it=l.begin();it!=l.end();it++){
cout<<*it<<'\t';
}
cout<<endl;
}
bool myCompare(int v1,int v2){
return v1>v2; //降序操作
}
void test(){
list<int>lst;
lst.push_back(10);
lst.push_back(323);
lst.push_back(32);
lst.push_back(2);
lst.push_back(56);
print(lst);
lst.sort(myCompare);
print(lst);
}
int main(){
test();
return 0;
}6.8 排序案例
需求：将Person自定义数据类型进行排序，Person中有姓名，年龄，身高。排序规则：按年龄进行升序排序，若年龄相同则按身高降序
#include<iostream>
#include<list>
#include<string>
#include<algorithm>
using namespace std;
class Person{
private:
string m_Name;
int m_Age;
int m_Height;
public:
friend void print(list<Person> &l);
friend bool order(Person &p1,Person &p2);
Person(string name,int age,int height){
m_Name=name;
m_Age=age;
this->m_Height=height;
}
};
//打印函数
void print(list<Person> &l){
for(list<Person>::iterator it=l.begin();it!=l.end();it++){
cout<<"姓名："<<it->m_Name<<" 年龄："<<it->m_Age<<" 身高："<<it->m_Height<<endl;
}
cout<<endl;
}
bool order(Person &p1,Person &p2){
if(p1.m_Age==p2.m_Age){
return (p1.m_Height>p2.m_Height);
}
else return (p1.m_Age<p2.m_Age);
}
void test(){
list<Person>lst;
Person p1("长伞",12,150);
Person p2("李迪",23,176);
Person p3("为例",19,180);
Person p4("标志",19,185);
Person p5("大幅",56,168);
Person p6("氪金",21,174);
lst.push_back(p1);
lst.push_back(p2);
lst.push_back(p3);
lst.push_back(p4);
lst.push_back(p5);
lst.push_back(p6);
print(lst);
lst.sort(order);
print(lst);
}
int main(){
test();
return 0;
}7. set/multiset 容器
所有元素在插入时会自动排序。set/multiset 容器属于关联式容器，底层结构是二叉树实现
set 不允许容器中有重复元素
multiset 允许容器中重复元素
插入数据只有 insert() 方式
构造函数：
set<T> st;
set(const set &st);
赋值
set& operator=(const set &st)
7.1 大小与互换
size(); //返回容器中元素数目
empty() //判断容器是否为空
swap(st); //交换两个容器元素
7.2 插入与删除
insert(elem);
clear();
erase(pos); //删除pos迭代器所指元素，返回下一个元素迭代器
erase(beg,end); //删除区间[beg.end)区间内元素，返回下一个元素迭代器
erase(elem); //删除容器中值为elem的元素
7.3 查找与统计
find(key); //查找key是否存在，返回该值元素迭代器；若不存在，返回set.end()
count(key); //统计key的元素个数，对于set实际上返回值为0或1；对于multiset可能不同
7.4 pair对组创建
成对出现的数据，利用对组可返回两个数据
pair<type,type> p (value1,value2);
pair<type,type> p=make_pair(value1,value2);
无头文件需要添加，访问方式为 p.first，p.second。
7.5 set容器排序
#include<iostream>
using namespace std;
#include<set>
//set内置类型指定排序规则
class myCompare{
public:
bool operator()(int v1,int v2){ //此处形参数据类型的依据是容器参数类型
return v1>v2;
}
};
void test01(){
set<int>s1;
s1.insert(10);
s1.insert(40);
s1.insert(50);
s1.insert(20);
s1.insert(30);
for(set<int>::iterator it=s1.begin();it!=s1.end();it++){
cout<<*it<<'\t';
}
cout<<endl;
}
void test02(){
set<int,myCompare>s2; //插入数据之前就要确定排序规则，以仿函数形式
s2.insert(10);
s2.insert(40);
s2.insert(50);
s2.insert(20);
s2.insert(30);
for(set<int,myCompare>::iterator it=s2.begin();it!=s2.end();it++){
cout<<*it<<'\t';
}
cout<<endl;
}
int main(){
test01();
test02();
return 0;
}#include<iostream>
using namespace std;
#include<set>
#include<string>
//自定义数据类型需指定排序规则
class Person{
public:
Person(string name,int age){
m_Name=name;
m_Age=age;
}
string m_Name;
int m_Age;
};
class myCompare{
public:
bool operator()(const Person &p1,const Person &p2){
return p1.m_Age>p2.m_Age;
}
};
void test01(){
set<Person,myCompare>s;
Person p1("链表",30);
Person p2("工艺",22);
Person p3("字符",28);
Person p4("作用",20);
s.insert(p1);
s.insert(p2);
s.insert(p3);
s.insert(p4);
for(set<Person,myCompare>::iterator it=s.begin();it!=s.end();it++){
cout<<"姓名为："<<it->m_Name<<'\t'<<"年龄为"<<it->m_Age<<endl;
}
cout<<endl;
}
int main(){
test01();
return 0;
}8. map/multimap容器
8.1 基本概念
map中所有元素都是pair，第一个元素为key（键值），起索引作用；第二个元素为value。所有元素都会根据其键值key自动排序。
map/multimap区别：map中不允许有重复key值
8.2 构造与赋值
map<T1,T2>mp;
map(const map &mp);
map& operator=(const map &mp);
#include<map>
#include<iostream>
using namespace std;
void test(){
map<int,int>m;
m.insert(pair<int,int>(1,10));
m.insert(pair<int,int>(2,20));
m.insert(pair<int,int>(3,30));
m.insert(pair<int,int>(4,40));
}
void print(map<int,int> &mp){
for(map<int,int>::iterator it=mp.begin();it!=mp.end();it++){
cout<<"key="<<(*it).first<<" value="<<it->second<<endl;;
}
cout<<endl;
}
int main(){
test();
return 0;
}8.3 插入与删除
#include<iostream>
#include<map>
using namespace std;
void print(map<int,int>&mp){
for(map<int,int>::iterator it=mp.begin();it!=mp.end();it++){
cout<<"key="<<(*it).first<<" value="<<it->second<<endl;
}
cout<<endl;
}
void test01(){
map<int,int>m;
//插入
m.insert(pair<int,int>(1,10));
m.insert(make_pair(2,20));
m.insert(map<int,int>::value_type(3,30));
m[4]=40; //不建议插入时使用，可利用key访问value
print(m);
//删除
m.erase(m.begin());
print(m);
m.erase(3); //删除key为3的value
print(m);
m.erase(m.begin(),m.end());
print(m);
m.clear();
}
int main(){
test01();
return 0;
}8.4 查找与统计
find(key); //查找key是否存在，返回该键的元素迭代器；若不存在，返回set.end()
count(key); //统计key的元素个数
map<int,int>m;
m.insert(make_pair(1,10));
m.insert(make_pair(2,20));
m.insert(make_pair(3,30));
map<int,int>::iterator pos=m.find(3); //返回值为键的元素迭代器，因此用迭代器接收
if(pos!=m.end()){
cout<<"查到元素key="<<(*pos).first<<" value="<<pos->second<<endl;
}
else cout<<"未找到元素"<<endl;8.5 排序
#include<iostream>
#include<map>
using namespace std;
class myCompare{
public:
bool operator()(int v1,int v2){
return v1>v2;
}
};
void test01(){
map<int,int,myCompare>m;
m.insert(make_pair(1,10));
m.insert(make_pair(2,20));
m.insert(make_pair(3,30));
m.insert(make_pair(4,40));
m.insert(make_pair(5,50));
for(map<int,int>::iterator it=m.begin();it!=m.end();it++){
cout<<"key="<<(*it).first<<" value="<<it->second<<endl;
}
cout<<endl;
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
