STL初识

参考链接：https://blog.csdn.net/weixin_43780415/article/details/130498763

1、基本概念

C++ STL（标准模板库）是一套功能强大的 C++ 模板类，提供了通用的模板类和函数，这些模板类和函数可以实现多种流行和常用的算法和数据结构，如向量、链表、队列、栈。

也就是说，在我们去自己定义模板类的时候每个人往往有自己的习惯，导致我们代码想要的结果一样但编码五花八门，为了使我们遵循统一的标准，才有了STL

• STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator)
• 容器和算法之间通过迭代器进行无缝连接。
• STL 几乎所有的代码都采用了模板类或者模板函数

2、六大组件

STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

1. 容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。
2. 算法：各种常用的算法，如sort、find、copy、for_each等
3. 迭代器：扮演了容器与算法之间的胶合剂。
4. 仿函数：行为类似函数，可作为算法的某种策略。
5. 适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
6. 空间配置器：负责空间的配置与管理。

3、vector存放内置数据类型（遍历）

方法一： 
 1 #include <vector>
 2 #include<algorithm>
 3 #include<iostream>
 4 //容器 vector
 5 //算法 for_each
 6 //迭代器 vector<int>::iterator
 7 using namespace std;
 8
 9 void test01() {
10
11     //创建vector容器对象，并且通过模板参数指定容器中存放的数据的类型
12     vector<int> v;
13     //向容器中放数据
14     v.push_back(10);
15     v.push_back(20);
16     v.push_back(30);
17     v.push_back(40);
18
19     //每一个容器都有自己的迭代器，迭代器是用来遍历容器中的元素
20     //v.begin()返回迭代器，这个迭代器指向容器中第一个数据
21     //v.end()返回迭代器，这个迭代器指向容器元素的最后一个元素的下一个位置
22     //vector<int>::iterator 拿到vector<int>这种容器的迭代器类型
23
24     vector<int>::iterator pBegin = v.begin();
25     vector<int>::iterator pEnd = v.end();
26
27     //第一种遍历方式：
28     while (pBegin != pEnd) {
29         cout << *pBegin << endl;
30         pBegin++;
31     }
32 }
33
34 int main()
35 {
36     test01();
37     system("pause");
38     return 0;
39 }
40  

方法二：

 1 void test01() {
 2
 3     //创建vector容器对象，并且通过模板参数指定容器中存放的数据的类型
 4     vector<int> v;
 5     //向容器中放数据
 6     v.push_back(10);
 7     v.push_back(20);
 8     v.push_back(30);
 9     v.push_back(40);
10
11     for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
12         cout << *it << endl;
13     }
14 }

方法三：

 1 #include <vector>
 2 #include<algorithm>
 3 #include<iostream>
 4 //容器 vector
 5 //算法 for_each
 6 //迭代器 vector<int>::iterator
 7 using namespace std;
 8 void MyPrint(int val)
 9 {
10     cout << val << endl;
11 }
12 void test01() {
13
14     //创建vector容器对象，并且通过模板参数指定容器中存放的数据的类型
15     vector<int> v;
16     //向容器中放数据
17     v.push_back(10);
18     v.push_back(20);
19     v.push_back(30);
20     v.push_back(40);
21
22     //第三种遍历方式：
23     //使用STL提供标准遍历算法  头文件 algorithm
24     for_each(v.begin(), v.end(), MyPrint);
25 }
26
27
28 int main()
29 {
30     test01();
31     system("pause");
32     return 0;
33 }
34  

4、向量vector

1. 向量属于顺序容器，用于容纳不定长线性序列（即线性群体），提供对序列的快速随机访问（也称直接访问）

2. 数据结构很像一个数组，所以与其他容器相比，vector 能非常方便和高效访问单个元素，支持随机访问迭代子

3. 向量是动态结构，它的大小不固定，可以在程序运行时增加或减少

与数组不同，向量的内存用尽时，向量自动分配更大的连续内存区，将原先的元素复制到新的内存区，并释放旧的内存区；这是向量类的优点

vector 基本操作
(1)头文件
#include<vector>

(2)创建vector对象
vector<int> vec;

(3)尾部插入数字
vec.push_back(a);

(4)使用下标访问元素
cout<<vec[0]<<endl;                         // 记住下标是从0开始的

(5)使用迭代器访问元素
vector<int>::iterator it;
for(it=vec.begin();it!=vec.end();it++)
cout<<*it<<endl;

(6)插入元素
vec.insert(vec.begin()+i,a);                // 在第i+1个元素前面插入a;

(7)删除元素
vec.erase(vec.begin()+2);                  // 删除第3个元素
vec.erase(vec.begin()+i,vec.end()+j); // 删除区间[i,j-1];区间从0开始

(8)向量大小
vec.size();
vec.resize;                                        // 改变大小

(9)清空
vec.clear();

示例如下：

 1 #include <iostream>
 2 #include <iomanip>
 3 #include <vector>    //包含向量容器头文件
 4 using namespace std ;
 5 void main(){
 6     vector<int>  A(10);      //创建vector对象
 7     int n;
 8     int primecount = 0, i, j;
 9     cout<<"Enter a value>=2 as upper limit: ";
10     cin >> n;
11     A[primecount++] = 2;//下标法访问元素
12     for(i = 3; i < n; i++){
13         if (primecount == A.size())
14             A.resize(primecount + 10); //改变容器大小
15         if (i % 2 == 0)
16             continue;
17         j = 3;
18          while (j <= i/2 && i % j != 0)
19             j += 2;
20         if (j > i/2) A[primecount++] = i;
21     }
22     for (i = 0; i<primecount; i++){//输出质数
23         cout<<setw(5)<<A[i];
24         if ((i+1) % 10 == 0) //每输出10个数换行一次
25             cout << endl;
26     }
27     cout<<endl;
28 }

5、列表list

链表主要用于存放双向链表，可以从任意一端开始遍历。链表还提供了拼接（splice）操作，将一个序列中的元素从插入到另一个序列中

对比：

元素的插入和删除操作对 list 而言尤为高效

与 vector 和 deque 相比，对元素的下标访问操作的低效是不能容忍的，因此 list 不提供这类操作

头文件：#include <list>

 1 #include <iostream>
 2 #include <list>
 3 using namespace std ;
 4 int main(){
 5     list<int> Link;    //构造一个列表用于存放整数链表
 6     int i, key, item;
 7     for(i=0;i < 10;i++)// 输入10个整数依次向表头插入{
 8         cin>>item;
 9         Link.push_front(item);
10     }
11     cout<<“List: ”; // 输出链表
12     list<int>::iterator p=Link.begin();
13     while(p!=Link.end()){ //输出各节点数据，直到链表尾
14         cout <<*p << "  ";
15         p++;  //使P指向下一个节点
16     }
17     cout << endl;
18     cout << "请输入一个需要删除的整数: ";
19     cin >> key;
20     Link.remove(key);
21     cout << "List: "; // 输出链表
22     p=Link.begin();    // 使P重新指向表头
23     while(p!=Link.end()){
24         cout <<*p << "  ";
25         p++; // 使P指向下一个节点
26     }
27     cout << endl;
28 }