学习C++之STL，看这篇就够啦（简单易懂），赶快收藏起来~

前言：

简单介绍
标准模板库 STL（Standard Template Library），是 C++ 标准库的一部分，不需要单独安装，只需要#include 头文件。C++中的模板，就好比英语作文的模板，只换主题，不换句式和结构。对应到C++模板，就是只换类型，不换方法。
STL有什么优势？
STL封装了很多实用的容器，省时省力，能够让你将更多心思放到解决问题的步骤上，而非费力去实现数据结构诸多细节上。

该文章简单介绍了c++之STL，该内容是在学习黑马程序员课程c++时所写的笔记。内容较长，建议收藏起来慢慢看~

vector容器

前言

迭代器支持随机访问
单端数组 与普通数组区别在于可动态扩展
输出函数

vector存放数据类型（数组）

1.创建一个vector容器 名字叫v：

vector v;

2.容器从后面插入元素

v.push_back();

3.通过迭代器访问容器中的数据

vector<int>::iterator itBegin = v.begin();   //起始迭代器  指向容器中的第一个元素
vector<int>::iterator itEnd = v.end();   //结束迭代器  指向容器中最后一个元素的下一个位置 

4.算法遍历

          first      end       fn
            |         |         | 
for_each(v.begin(),v.end(),myPrint);

二、vector嵌套

1.vector<vector> v;

vectorv1;

vectorv2;

三、vector构造函数

1.直接构造

vector v1;

2.区间构造

vectorv2(v1.begin(),v1.end());

3.n个elem构造

vectorv3(4,10); //10,10,10,10

4.拷贝构造 （最常用！）

vectorv4(v3); // v3拷贝到v4； （10,10,10,10）

四、vector赋值

1.等号赋值operator =

v2 = v1;

2.assign赋值

v3.assign(v1.begin(),v1.end());

assign的n个elem方式

v4.assign(4,100); //4个100； 100 100 100 100

五、vector容量和大小

v.empty()            //为真true 代表容器为空 
v.capacity()         //capacity显示容量大小 
v.size()             //size显示存的大小   

//重新指定大小--v.resize
v1.resize(15,100);//第二个参数可指定填充值
//如果重新指定的比原来长了，默认用0填充新位置 
v1.resize(5);                    
//如果重新指定的比原来短了，超出部分会删除 

六、vector插入和删除

//尾插--push_back
v1.push_back(10);    //可以插入变量
v1.push_back(20);

//尾删--pop_back
v1.pop_back();            //删除最后一个

//插入--insert     // 第一个参数是迭代器
v1.insert(v1.begin(),100); //插入在第一个,元素为100
v1.insert(v1.begin(),2,1000); //(pos, num, ele);第二个参数默认为1(个)

//删除--erase      //参数是迭代器 
v1.erase(v1.begin());    //删除第一个
//重载版本  区间删除 
v1.erase(v1.begin()+1,v1.end()-1);   //留下第一个和最后一个

//清空--clear
v1.clear();

七、vector数据存取

// 访问元素
v[1]       //利用[]方式访问数组中元素
v.at(1)    //利用at()方式访问数组中元素

// 第一个元素--front
v.front()          //获取第一个元素  v.begin()是获得第一个的迭代器
//最后一个元素--back
v.back()          //获取最后一个元素   v.end()同理，迭代器

八、vector的交换

swap基础运用 (指针互换）
v1.swap(v2);
//实际用途  收缩内存空间
vector<int>(v1).swap(v1);//vector<int>(v1)为创建了匿名对象拷贝了v1所用容量的大小和数据，交换后会自动释放空间 

九、vector预留空间

预留空间–reserve

v.reserve(10000) //当空间比较大时，可以提前开辟大的内存空间,以此减少数据开辟次数

deque容器

前言

双端数组
迭代器支持随机访问

vector对于头部的插入删除效率低，数据量越大，效率越低
deque相对而言，对头尾部的插入删除速度回比vector快
vector访问元素时的速度会比deque快,这和两者内部实现有关

deque容器 (指针数组) 每个指针指向一片缓冲区，缓冲区满了再插就换一个缓冲区插入

//deque遍历
deque<int>d;
void printDeque(const deque<int>&d)   //地址输入
{
	for(deque<int>::const_iterator it = d1.begin();it != d1.end();it++)
	{             //const_iterator只读不写 
		cout << *it <<" ";
	}
	cout<<endl;
}
printDeque(d1);

一、deque构造

//1.直接构造
deque<int> d1;
//2.区间构造 
deque<int> d2(d1.begin(),d1.end());
//3.n个elem
deque<int> d3(10,100);   //10个100 
//4.拷贝构造
deque<int>d4(d3);        

二、deque赋值(同vector)

//等号赋值
deque<int> d2 = d1;
//assign赋值
d3.assign(d1.begin(),d1.end());
d4.assign(10,100);

三、deque大小操作

//1.判断是否为空--empty
v.empty();     //deque容器没有容量概念 
//2.返回元素个数--size
v.size();     
//3.重新指定元素个数
v.resize();      //详细见vector

四、deque头(front)尾(back)插(push)头尾删(pop)

1.头插

v.push_front();

2.尾插

v.push_back();

3.头删

v.pop_front();

4.尾删

v.pop_back();

五、deque插入和删除（迭代器）

//1.insert插入（头部插入） 提供迭代器 
d1.insert(d1.begin(),1000);  头部插入1000
d1.insert(d1.begin(),2,2000);  头部插入2000 2000

//按照区间进行插入
deque<int>d2;
d2.push_back(1);
d2.push_back(2);
//在d1的头部插入d2的区间里的数据 
d1.insert(d1.begin(),d2.begin(),d2.end());

//2.删除--erase
deque<int>::iterator it = d1.begin();
it++;//迭代器指向第1位 
d1.erase(it);   //删除的是第二个元素

//按照区间方式删除  提供迭代器 
d1.erase(d1.begin(),d1.end());
//清空
d2.clear();

六、deque数据存取

d[i]        //通过[]方式访问第i个元素 
d.at(i)       //通过at访问第i个元素
d.front()         //访问第一个元素
d.back()          //访问最后一个元素

七、sort排序

排序(需要包含算法头文件（#include ）） 默认升序
对于支持随机访问的迭代器的容器，都可以用sort排序
vector也可以用sort
sort(d.begin(),d.end());

list容器

前言

双向循环链表 优点：可以对任意位置进行快速插入或删除元素
为双向迭代器 支持前移和后移
缺点：容器遍历速度没有数组快，占用空间比数组大

构造函数

list l1;

//添加数据
l1.push_back(10);
l1.push_back(20);
l1.push_back(30);

//区间方式构造
listl2 (l1.begin(),l1.end());

//拷贝构造
listl3 (l2);

//n个elem
listl4(10,1000);

赋值

//等号赋值
list l2;
l2 = l1;

//assign赋值
list<int> l3;
l3.assign(l2.begin(),l2.end());

//list<int> l4;
l4.assign(10,100);

交换–swap

l1.swap(l2);

大小操作

1.判断是否为空–empty

l1.empty();

2.返回元素个数–size

l1.size();

3.重新指定大小–resize

l1.resize(10,1000); 长了（详细见vector）

l1.resize(2); 短了

插入和删除

1.头插和尾插

l1.push_front(10); l1.pop_front(10);

l1.push_back(10); l1.pop_back(10);

2.插入–insert(迭代器)

list::iterator it = l1.begin();
l1.insert(++it,1000);

3.删除–erase(迭代器)
it = l1.begin();

l1.erase(++it);

4.移除--remove(删除容器中与elem值匹配的所有的元素) 
l1.push_back(10000);
l1.push_back(10000);
l1.remove(10000);
5.清空
l1.clear();

数据存取

list数据存取(没有at和[])

l1[0]不可以访问list容器的元素
l1.at(0)不可以用at方式访问list容器的元素
原因是list本质是链表，不是连续线性空间存储数据，迭代器也不支持随机访问 

l1.front()             //第一个元素
l1.back()              //最后一个元素
//验证迭代器是不支持随机访问
list<int>::iterator it = l1.begin();
it++;//支持双向
it--;
//it = it + 1;//不支持随机访问 

反转–reverse

l1.reverse();

排列–sort

l1.sort();//默认排序规则 从小到大 升序

sort(l1.begin(),l1.end());     // （error）
//所有不支持随机访问的迭代器不可以用标准算法
//不支持随机访问迭代器的容器，内部会提供对应的一些算法

//降序排列 
//降序排列的函数
bool myCompare(int v1, int v2)
{
    //降序 就让第一个 > 第二个数
    return v1 > v2; 
 } 
l1.sort(myCompare);             //传入一个自定义规则的函数排序

map容器

前言（map与multimap）

map中元素都是pair

pair中第一个元素为key(键值)，第二个元素为value(实值)，所有元素按照键值排序

map不允许插入重复的key值（可以重复的value），multimap可以

遍历输出

void printMap(map<int,int>&m)
{
	for(map<int,int>::iterator it = m.begin();it != m.end();it++)
	{
		cout<<"key = "<<(*it).first<<"value = "<<it->second<<endl;
	}
	cout<<endl;
}

构造与赋值

map<int,int> m;      //默认构造
m2(m);               //拷贝构造
m3 = m2;             // = 赋值

大小和交换

m.empty();

m.size();

m1.swap(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;
	cout<<m[4]<<endl; 
//[]不建议插入，用途可以利用key访问到value
	cout<<m[5]<<endl;  // 

//删除
m.erase(m.begin());      //删除第一个
m.erase(3);              //按照key删除

e.erase(m.begin(),m.end());   //删除区间
e.clear();            //清空

quque容器

前言

队列 特点 ==先进先出 ==只有队头队尾才能访问 因此不允许遍历

构造

queue q;

q1(q2);

赋值

q1 = q2;

数据存取

s.push(elem); //往队尾添加元素

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

s.back(); //返回最后一个元素

s.front(); //返回第一个元素

大小操作

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

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

set容器

前言

set不可插入重复元素

multiset可插入重复元素

插入数据–insert

1.只有insert方式

s.insert(10);
s.insert(10);
s.insert(20);  
s.insert(30);         //输出--> 10  20  30
//set容器特点：1.所有元素插入的时候自动被排序
//             2.不允许插入重复值

2.拷贝构造

s1(s2);

3.赋值

s3 = s2;

大小和交换（无重置resize）

是否空–s.empty();

大小–s.size();

交换–s1.swap(s2);

插入和删除

//插入
s1.insert(200);
s1.insert(100);
s1.insert(300);        //100 200 300
//删除
s1.erase(s1.begin());      //200 300
//删除指定元素
s1.erase(300);
//删除整个容器
s1.erase(s1.begin(),s1.end());
//清空
s1.clear();

查找和统计

//查找--find（返回一个迭代器）
set<int>::iterator pos = s1.find(30);

//若找到30元素，返回该元素迭代器
//若未找到元素，返回s1.end()

//统计--count
int num = s1.count(30);

//set返回结果要么是0要么是1

pair队组创建

//1.方式一
pair<string,int> p1 ("Tom",20);
cout<<"姓名："<< p1.first <<"年龄：" <<p1.second <<endl;
//2.方式二
pair<string,int> p2 = make_pair("Jerry",10);
cout<<"姓名："<< p2.first <<"年龄：" <<p2.second <<endl;

set容器排序

//改变排序规则
class mycompare
{
    public:
        bool operator()(const int v1,const int v2)
        {
            return v1 > v2;    //从大到小
        }
 };
void test7()
{
    set<int,mycompare> s;    
    //先指定规则，后插入数据,第一个数为数据类型，第二个数为仿函数(排序规则)
    
    s.insert(20);
    s.insert(40);
    s.insert(30);
    for(set<int>::iterator it = s.begin();it != s.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
 } 
     //40  30  20

自定义排序

class person
{
	public:
		person(string name,int age)
		{
			this->mname = name;
			this->mage = age;
		}
		string mname;
		int mage;
 }; 
class compareperson
{
	public:
		bool operator()(const person&p1,const person&p2)
		{
			//返回年龄大的
			return p1.mage > p2.mage; 
		}
};
void test8()
{
	set<person,compareperson> s;
	person p1("刘备",17);
	person p2("刘邦",18);
	person p3("张三",16);
	
	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	
	for(set<person,compareperson>::iterator it = s.begin();it != s.end();it++)
	{
		cout<<"名字："<<it->mname<<"年龄："<<it->mage<<endl;
	}
	cout<<endl;
}

stack容器

前言

符合先进后出数据结构(类似杯子，弹夹）,不允许遍历

栈中进入数据称为–入栈

栈中进入数据称为–出栈

构造函数

stack s;

s1(s2);

赋值

s1 = s2;

数据存取

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

大小操作

s.empty(); — !s.empty() 取反不为空

s.size();

string容器

构造字符串

1.默认构造

string s1;

2.n个a的字符串

string s2(4,‘a’); //s2 = aaaa

3.复制字符串

string s3(s2);

赋值（= 或 assign）

1.直接赋值

s1 = “”;

2.n个a的字符串构造

string s2(4,‘a’);

拼接

1.字符串拼接

s1 += s2;

s1 += “aaaa”;

查找–（find与rfind）

int pos = s.find(“ae”); //从做开始查找

若 s字符串中没有"ae"，则返回-1；否则返回搜索字符的第一的元素的下标

eg：

s = “124aed5”;

pos = 3;

替换–replace

s.replace(1,3,“aaaaa”); //从第1个下标元素开始3个，替换成aaaaa

比较–compare

按照字符的ASCII码比较

=返回0 >返回1 <返回-1

s1.compare(s2);

插入–insert

s.insert(1,“aaaaa”); 第一个下标插入aaaaa

删除–erase

删除后长度跟着改变；

s.erase(1,3); //从下标第1开始往后删3个元素

s.erase(s.begin(),s.end()); //删除一整行 == [ , );==

截取–substr

s.substr(0,pos); //从下标为0的元素开始取到pos前的位置

总结

以上就是今天要分享的内容，本文简单介绍了c++之STL，该内容是在学习黑马程序员课程c++时的笔记，希望能够帮助到大家，如果你觉得还不错可以点个赞支持一下哦，欢迎一起交流学习。