✍个人博客：https://blog.csdn.net/Newin2020?spm=1011.2415.3001.5343
📚专栏地址：C/C++知识点
📣专栏定位：整理一下 C++ 相关的知识点，供大家学习参考~
❤️如果有收获的话，欢迎点赞👍收藏📁，您的支持就是我创作的最大动力💪
🎏唠叨唠叨：在这个专栏里我会整理一些琐碎的 C++ 知识点，方便大家作为字典查询~

STL

概述

STL，学名Standard Template Library，一般称它为标准模板库。

C++ 对模板（Template）支持得很好，STL 就是借助模板把常用的数据结构及其算法都实现了一遍，并且做到了数据结构和算法的分离。例如，vector 的底层为顺序表（数组），list 的底层为双向链表，deque 的底层为循环队列，set 的底层为红黑树，hash_set 的底层为哈希表。

从根本上说，STL是一些“容器”的集合，这些“容器”有list,vector,set,map一大堆，STL也是算法和其他一些组件的集合。比如说中sort函数。

STL基本组成

STL从广义上讲分为三类：

1. 容器（Container），是一种数据结构，如list，vector，和deques ，以模板类的方法提供。为了访问容器中的数据，可以使用由容器类输出的迭代器；
2. 迭代器（Iterator），提供了访问容器中对象的方法。例如，可以使用一对迭代器指定list或vector中的一定范围的对象。迭代器就如同一个指针。事实上，C++的指针也是一种迭代器。但是，迭代器也可以是那些定义了operator*()以及其他类似于指针的操作符地方法的类对象；
3. 算法（Algorithm），是用来操作容器中的数据的模板函数。例如，STL用sort()来对一个vector中的数据进行排序，用find()来搜索一个list中的对象，函数本身与他们操作的数据的结构和类型无关，因此他们可以在从简单数组到高度复杂容器的任何数据结构上使用；

string容器

用字符数组存放字符串容易发生数组越界的错误，而且往往难以察觉。因此，C++ 标准模板库设计了string 数据类型，专门用于字符串处理。

要使用string 对象，须包含头文件。

在用C++ 编程时，要优先考虑用string 对象来处理字符串，因为其用法比字符数组更简单，而且不容易出错。

初始化

string对象的初始化和普通类型变量的初始化基本相同，只是string作为类，还有类的一些特性：使用构造函数初始化。

string s1; //默认初始化，一个空字符串s1
string s2(s1); //s2是s1的副本
string s3 = s1; //等价于s3（s1）,s3是s1的副本
string s4(“hello”); //s4是字面值”hello”
string s5 = “hello”; //等价于上行代码
string s6(n,’a’); //把s6初始化为由连续的n个字符c组成的串
//调用string的构造函数生成一个临时的string类，再用临时的string类初始化。
string s7 = string(“hello”);
string s8(string(“hello”));

输入输出

1. cin 输入

string s1;
cin >> s1; //遇到空格终止
cout << s1 << endl;

2. getline读取整行

string s1;
getline(cin,s1);
cout << s1 << endl;

vs里面使用getline，须加上#include

比较大小

string可以直接使用> ,< == 等进行比较。

string s1 = “abc”,s2=”eda”;
s1 > s2
s1 < s2
s1 == s2

链接

string可以使用+来直接链接。

string s1 = “hello”,s2 = “ world”;
string s3 = s1 + s2;

获取字符

1. 使用C++11新特性的for

string s1 = “abcdefg”;
for (auto c:s1){cout << c << “ “;
}

2. 使用运算符[] + size()函数

s1[0];
s1[1];
s1[2];

3. 使用迭代器

string s1 = “hello world”;
for(auto i=s1.begin();i!=s1.end();i++){cout << *i << “ “;
}

拷贝string对象

第一个将s1从下标pos开始拷贝到结尾。当pos>s1.size()时，为未定义行为；当pos=s1.size()，拷贝一个空字符。

第二个将s1从下标pos开始拷贝，拷贝len个字符。当pos>s1.size()时，为未定义行为；当pos=s2.size()，拷贝一个空字符。

string s(s1,pos);
string s(s1,pos,len);

案例：

string s1("hello");
(1) string s2(s1, 1);//s2为”ello”,长度为4
(2) string s3(s1, 5);//s3为””,长度为0
(3) string s8(s1, 6);// 错误，未定义的行为，抛出异常
(4) string s4(s1, 1, 3);// s4为”ell”,长度为3
(5) string s5(s1, 1, 8);// 正确，s5为”ello”,长度为4
(6) string s6(s1, 5, 8);// s6为””,长度为0
(7) string s7(s1, 6, 1);// 错误，未定义的行为，抛出异常

substr函数

返回一个string对象，返回的对象包含s从pos下标开始的n个字符。pos和n均为可选参数。pos默认为下标0；n默认为s.size()-pos。

s.substr(pos,n);

案例：

string s ("value");
(1)string s2 = s.substr();//s2为”value”,大小为5
(2)string s3 = s.substr(2);//s3为”lue”,大小为3
(3)string s4 = s.substr(5);//s3为””,大小为0
(4)string s5 = s.substr(6);//错误，s5的大小为pos = 5，小于s.size()
(5)string s6 = s.substr(1,2);// s6为”al”,大小为2
(6)string s7 = s.substr(1,7);// s7为”alue”,大小为4
(7)string s8 = s.substr(5,7);// s8为””,大小为0
(8)string s9 = s.substr(6,7);// 错误，s9的大小为pos = 5，小于s.size()

insert函数

1. iterator insert( iterator pos, CharT ch )
2. void insert( iterator pos, size_type count, CharT ch )
3. void insert( iterator pos, InputIt first, InputIt last )
4. 插入初始化列表

案例：

string s1("value");
s1.insert(s1.begin(), 's');//执行后，s1为"svalue"
s1.insert(s1.begin(), 1, 's');//执行后，s1为"ssvalue"
s1.insert(s1.begin(), s1.begin(), ++s1.begin());//执行后，s1为"sssvalue"
s1.insert(s1.end(), {'1','2'});//执行后，s1为"sssvalue12"

erase函数

//删除s从pos下标开始的n个字符，并返回删除后的s。当pos > s.size()时，报错
basic_string & erase(size_type pos=0, size_type n=npos);//删除s迭代器position位置的字符，并返回下一个字符的迭代器。
iterator erase(const_iterator position);//删除s迭代器[first,last)区间的字符，并返回last字符的迭代器。
iterator erase(const_iterator first, const_iterator last);

案例：

string s1("value");
string s2("value");
string s3("value");
string s4("value");
s1.erase();//执行后，s1为空
s2.erase(0,2); //执行后，s2为”lue”
s2.erase(1); //执行后，s2为"l"
s3.erase(s3.begin());//执行后，s3为”alue”
s4.erase(s4.begin(),++s4.begin());//执行后，s4为”alue”

append函数

append是在string对象的末尾进行插入操作，这一点使用+运算符也能做到。

案例：

string s="C++";
s.append("program");//执行完后，s=”C++program”

replace函数

案例：

string s("i very love China!");const char* cp1 = "truly";
const char* cp2 = "truly!!!";string str1 = "really";
string str2 = "really!!!";//1.将s从下标2开始删除4个字符，删除后在下标2处插入cp1
s.replace(2,4,cp1);//s=” i truly love China!”
//2.将s从下标2开始删除5个字符，删除后在下标2插入cp2的前5个字符
s.replace(2, 5, cp2,5); //s=” i truly love China!”
//3.将s从下标2开始删除5个字符，删除后在下标2插入str1
s.replace(2, 5, str1);//s=”i really love China!”
//4.将s从下标2开始删除6个字符，删除后在下标2插入str2从下标0开始的6个字符
s.replace(2, 6, str2, 0, 6);//s=”i really love China!”
//5.将s从下标2开始删除6个字符，删除后在下标2插入4个’*’字符
s.replace(2, 6, 4, '*');//s=”i **** love China!”

其他函数

1. find( )函数

string s = "1230,3210,220";
int start = 0;
int index = s.find(',', start);	//从下标为0开始查找，返回第一个','的下标，如果找不到返回-1

2. ispunct()函数：判断字符是否是标点符号用ispunct()

string s;
cin >> s;
for (auto each : s) {if (!ispunct(each)) {cout << each;}
}

vector容器

c++ 中，vector 是一个十分有用的容器。它能够像容器一样存放各种类型的对象。也就是说，vector是一个能够存放任意类型的动态数组。

vector 是同一种类型的对象的集合，每个对象都有一个对应的整数索引值。和string 对象一样，标准库将负责管理与存储元素相关的内存。

把vector 称为容器，是因为它可以包含其他对象。一个容器中的所有对象都必须是同一种类型的。

头文件

使用vector须包含头文件vector

#include 

声明与初始化

vector 可以声明各种类型，整型、字符型、字符串等等！

//整形数组
vector  vec = { 1,2,3,4,5};
//char型数组
vector  vec1 = {'h','e','l' ,'l' ,'o' };
//double
vector vec2 = {1.1,2.2,3.3};

利用构造函数初始化

vector()：创建一个空vector vector(int nSize):创建一个vector,元素个数为nSize

vector(int nSize,const t& t)：创建一个vector，元素个数为nSize,且值均为t

vector(const vector&)：复制构造函数

vector(begin,end)：复制[begin,end)区间内另一个数组的元素到vector中

案例：

vector  vec(10);//定义一个含10个变量的整型数组vec，默认值都为0
vector  vec(10,2);//定义一个含10个变量的整型数组vec，默认值都为2
vector vec(a);//其中a也是vector，把a整体赋值给vec
vector vec(a.begin(),a.begin+1);//把a的从开始到第二个赋值给vec

遍历函数

reference at(int pos)：返回pos位置元素的引用

reference front()：返回首元素的引用

reference back()：返回尾元素的引用

iterator begin()：返回向量头指针，指向第一个元素

iterator end()：返回向量尾指针，指向向量最后一个元素的下一个位置

reverse_iterator rbegin()：反向迭代器，指向最后一个元素

reverse_iterator rend()：反向迭代器，指向第一个元素之前的位置

案例：

vector v = { 1,2,3,4,5,6 };
cout << v.at(1) << endl; // 打印2
cout << v.front() << endl; //打印1
cout << v.back() << endl; // 打印6
for (auto i = v.begin(); i != v.end(); i++) {cout << *i << " ";
}
//输出1 2 3 4 5 6
cout << endl;
for (auto i = v.rbegin(); i != v.rend(); i++) {cout << *i << " ";
}
//输出6 5 4 3 2 1

添加函数

//向量尾部增加一个元素X
void push_back(const T& x);//向量中迭代器指向元素前增加一个元素x
iterator insert(iteratorit,const T& x);//向量中迭代器指向元素前增加n个相同的元素x
iterator insert(iterator it,int n,const T& x);//向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据
iterator insert(iterator it,const_iterator first,const_iterator last);

案例：

vector v = { 1,2 };
vector v2 = { 100,200 };
v.push_back(3);
v.insert(v.begin(), 11);
v.insert(v.begin() + 1, 3, 22);
v.insert(v.begin(), v2.begin(), v2.end());
for (auto i = v.begin(); i != v.end(); i++) {cout << *i << " ";
}
//输出100 200 11 22 22 22 1 2 3

删除函数

iterator erase(iterator it)：删除向量中迭代器指向元素

iterator erase(iterator first,iterator last)：删除向量中[first,last)中元素

void pop_back()：删除向量中最后一个元素

void clear()：清空向量中所有元素

案例：

vector v = { 1,2,3,4,5,6 };
v.erase(v.begin()+1);//删除2
v.erase(v.begin() + 2, v.begin() + 4); //删除4 ，5
v.pop_back(); //删除最后一个元素
v.clear(); //清空所有元素
for (auto i = v.begin(); i != v.end(); i++) {cout << *i << " ";
}

判断函数

bool empty() const：判断向量是否为空，若为空，则向量中无元素，返回1；反之，返回0

cout << v.empty() << endl;

大小函数

int size() const：返回向量中元素的个数

int capacity() const：返回当前向量所能容纳的最大元素值

int max_size() const：返回最大可允许的vector 元素数量值

案例：

vector v = { 1,2,3,4,5,6 };
cout << v.size() << endl;	//输出6
cout << v.capacity() << endl;	//输出6
cout << v.max_size() << endl;	//输出4611686018427387903

其他函数

1. void swap(vector&)：交换两个同类型向量的数据
2. void assign(int n,const T& x)：设置向量中前n个元素的值为x
3. void assign(const_iterator first,const_iterator last)：向量中[first,last)中元素设置成当前向量元素

stack容器

stack（栈）容器是一种先进后出的容器，两端只有一个开口，只能从这一个开口插入和删除数据。

头文件

使用时包含头文件stack

#include

构造函数

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

赋值函数

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

数据存取

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

大小函数

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

queue容器

Queue是一种先进先出（First In First Out,FIFO）的数据结构，它有两个出口。

1. 队列容器允许从一端新增元素，从另一端移除元素
2. 队列中只有对头和队尾才可以被外界使用，因此队列不允许有遍历的行为
3. 队列中进数据称为–入队push
4. 队列中出数据称为–出队pop

头文件

queue模版类的定义在头文件中。

#include

构造函数

queue queT;//queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que);//拷贝构造函数
//案例
queue q1;
queue q2(q1);

相关函数

push(elem);//往队尾添加元素
pop();//从队头移除第一个元素
back();//返回最后一个元素
front();//返回第一个元素
empty();//判断队列是否为空
size();//返回队列的大小

deque容器

deque双端队列，可以对头端和尾端进行插入删除操作。

deque队列为一个给定类型的元素进行线性处理，像向量一样，它能够快速地随机访问任一个元素，并且能够高效地插入和删除容器的尾部元素。但它又与vector不同，deque支持高效插入和删除容器的头部元素。

构造函数

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

案例：

deque a; // 定义一个int类型的双端队列a
deque a(10); //定义一个int类型的双端队列a，并设置初始大小为10
deque a(10, 1); //定义一个int类型的双端队列a，并设置初始大小为10且初始值都为1
deque b(a); //定义并用双端队列a初始化双端队列b
deque b(a.begin(), a.begin()+3); //将双端队列a中从第0个到第2个(共3个)作为双端队列b的初始值

添加函数

d.push_front(const T& x);//头部添加元素
d.push_back(const T& x);//末尾添加元素
d.insert(iterator it, const T& x);//任意位置插入一个元素
d.insert(iterator it, int n, const T& x);//任意位置插入n 个相同元素
d.insert(iterator it, iterator first, iterator last);//插入另一个向量的[forst,last] 间的数据

案例：

#include 
#include 
using namespace std;
int main(){deque d1;//头部增加元素d1.push_front(4);//末尾添加元素d1.push_back(5);//任意位置插入一个元素deque::iterator it = d1.begin();d1.insert(it, 2);//任意位置插入n个相同元素it = d1.begin(); d1.insert(it, 3, 9);//插入另一个向量的[forst,last]间的数据deque d2(5, 8);it = d1.begin(); d1.insert(it, d2.end() -1, d2.end());//遍历显示for (it = d1.begin(); it != d1.end(); it++)cout << *it << " "; // 输出：8 9 9 9 2 4 5cout << endl;return 0;
}

删除函数

d1.pop_front();//头部删除元素
d1.pop_back();//末尾删除元素
d1.erase(iterator it);//任意位置删除一个元素
d1.erase(iterator first, iterator last);//删除[first,last] 之间的元素
d1.clear();//清空所有元素：

访问函数

下标访问：deq[1]; // 并不会检查是否越界

at 方法访问：deq.at(1); // 以上两者的区别就是 at 会检查是否越界，是则抛出 out of range 异常

访问第一个元素：deq.front();

访问最后一个元素：deq.back();

大小函数

d.size();//容器大小
d.max_size();//容器最大容量
d.resize();//更改容器大小
deq.empty();//容器判空
deq.shrink_to_fit();//减少容器大小到满足元素所占存储空间的大小

其他函数

deq.assign(int nSize, const T& x); //多个元素赋值
// 类似于初始化时用数组进行赋值swap(deque&);//交换两个同类型容器的元素

案例：

#include 
#include 
using namespace std;
int main(){// 多个元素赋值deque d1;d1.assign(3, 1);deque d2;d2.assign(3, 2);// 交换两个容器的元素d1.swap(d2);// 遍历显示cout << "d1: ";for (int i = 0; i < d1.size(); i++)cout << d1[i] << " "; // 输出：2 2 2cout << endl;// 遍历显示cout << "d2: ";for (int i = 0; i < d2.size(); i++)cout << d2[i] << " "; // 输出：1 1 1cout << endl;return 0;
}

list容器

list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的，list中的数据元素是通过链表指针串连成逻辑意义上的线性表，也就是list也具有链表的主要优点，即：在链表的任一位置进行元素的插入、删除操作都是快速的。

头文件

#include

初始化

list l1; //创建一个空链表
list l2(10); //创建一个链表其有10个空元素
list l3(5,20); //创建一个链表其有5个元素内容为20
list l4(l3.begin(),l3.end()); //创建一个链表其内容为l3的内容
list l5(l4); //创建一个链表其内容为l4的内容

迭代器

遍历元素：

list li={1,2,3,4,5,6};
for(list::iterator it=li.begin();it!=li.end();it++){cout<<*it<<' ';
}

也可以使用auto

常用函数

empty()：返回一个bool类型的值，只存在真和假，当链表为空时为真，不为空时为假

size()：返回链表元素的个数

链表前插入push_front()：表示在链表最前端插入一个数据

删除pop_front()：表示在链表最前端删除一个数据

链表后插入push_back()：表示在链表尾插入一个数据

删除pop_back()：表示将链表尾删除一个数据

插入insert()：插入元素到指定位置，通过在元素之前在指定位置插入新元素来扩展向量，从而有效地增加容器大小所插入的元素数量。

//插入单一数据到指定位置
iterator insert (iterator position, const value_type& val);
//插入一段数据到指定位置
void insert (iterator position, size_type n, const value_type& val);
//插入一段别的容器的数据到指定位置
template 
void insert (iterator position, InputIterator first, InputIterator last);//案例
li.insert(li.begin(),100); //在链表最前端插入数据100
li.insert(li.begin(),3,200); //在链表最前端插入3个数据内容为200
list k(2,50); //创建一个新的链表k,其拥有2个元素内容均为50
li.insert(li.begin(),li.begin(),li.end()); //在链表v最前端插入链表上K的全部内容

erase()：删除一个元素，或者是一段区间的元素，将会自动缩减空间使用。

iterator erase (iterator position);
iterator erase (iterator first, iterator last);//案例
li.erase(li.begin()); //删除
li.erase(li.begin(),li.begin()+4); //删除前4个元素

排序sort()：让整个链表变成升序状态，或者变成自定义的排序状态

template  void sort (Compare comp);//案例
#include
#include
using namespace std;
int cmp(const int &a,const int &b){ return a>b;//简单的自定义降序序列
}
int main(){list li; //创建一个空链表for(int i=10;i>=6;i--){li.push_back(i);}li.push_front(3);li.push_back(20);list li2(li);for(list::iterator it=li.begin();it!=li.end();it++){cout<<*it<<' ';}cout<::iterator it=li.begin();it!=li.end();it++){cout<<*it<<' ';}cout<::iterator it=li2.begin();it!=li2.end();it++){cout<<*it<<' ';}cout<

Lst1.assign() 给list赋值
Lst1.back() 返回最后一个元素
Lst1.begin() 返回指向第一个元素的迭代器
Lst1.clear() 删除所有元素
Lst1.empty() 如果list是空的则返回true
Lst1.end() 返回末尾的迭代器
Lst1.erase() 删除一个元素
Lst1.front() 返回第一个元素
Lst1.get_allocator() 返回list的配置器
Lst1.insert() 插入一个元素到list中
Lst1.max_size() 返回list能容纳的最大元素数量
Lst1.merge() 合并两个list
Lst1.pop_back() 删除最后一个元素
Lst1.pop_front() 删除第一个元素
Lst1.push_back() 在list的末尾添加一个元素
Lst1.push_front() 在list的头部添加一个元素
Lst1.rbegin() 返回指向第一个元素的逆向迭代器
Lst1.remove() 从list删除元素
Lst1.remove_if() 按指定条件删除元素
Lst1.rend() 指向list末尾的逆向迭代器
Lst1.resize() 改变list的大小
Lst1.reverse() 把list的元素倒转
Lst1.size() 返回list中的元素个数
Lst1.sort() 给list排序
Lst1.splice() 合并两个list
Lst1.swap() 交换两个list
Lst1.unique() 删除list中重复的元素

set st 默认构造函数
set(const set &st) 拷贝构造函数
set& operator=(const set &st) 重载等号操作符

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

size() 返回容器中元素的数目
empty() 判断容器是否为空
swap(st) 交换两个集合容器

find(key) 查找key是否存在，若存在返回该键的元素的迭代器；若不存在，返回set.end()
count(key) 统计key的元素个数

#include
#include 
using namespace std;
//set容器的查找与统计
int main() {set s1;//插入数据s1.insert(20);s1.insert(30);s1.insert(10);s1.insert(40);//查找set::iterator pos = s1.find(30);if (pos != s1.end()) {//找到元素cout << "找到该元素:" << *pos << endl;}else {cout << "未找到该元素" << endl;}//统计//这里需要注意set容器不予许出现重复的元素//因此count返回的值只能为0或者1//统计30的个数s1.insert(30);s1.insert(30);int num = s1.count(30);cout << "30的个数为:" << num << endl; //1return 0;
}

#include

template  struct pair;

pair p;
pair p(10,20);

map m;
m.insert(pair('a',10));

//数据类型
pairp("公孙离", 17);
cout << "姓名:" << p.first << " 年岁:" << p.second << endl;
//和结构体类似，first代表第一个元素，second代表第二个元素
pairp1=make_pair(‘p’,3.14);
cout << "字符:" << p1.first << " 小数:" << p1.second << endl;

pair p;
p.first=10,p.second=20;

pair p;
p=make_pair(10,20);

map mmap 默认构造函数
map(const map &mp) 拷贝构造函数
map& operator=(const map &mp) 重载等号操作符

#include
#include

size() 返回容器中元素的数目
empty() 判断容器中是否为空
swap(st) 交换两个集合容器

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

#include
#include 

find(key) 查找key是否存在，返回该键的元素的迭代器；若不存在返回map.end()
count(key) 统计key的元素的个数

#include
#include