STL初识

2.1. STL的诞生

• 长久以来，软件界一直希望建立一种可重复利用的东西
• C++面向对象和泛型编程的思想，目的就是为了提高代码的复用性
• 大多数情况下，数据结构和算法都没有一套统一的标准，导致程序员被迫从事大量重复的工作
• 为了建立数据结构和算法的统一标准，STL诞生了

2.2. STL基本概念

• STL（Standard Template Library，标准模板库）
• STL广义上分为：容器（container）、算法（algorithm）、迭代器（iterator）
• 容器和算法之间通过迭代器进行无缝衔接
• STL几乎所有的代码都采用了模板类或模板函数

2.3. STL六大组件

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

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

2.4. STL中的容器、算法、迭代器

容器：用来放置物品的物件

STL中的容器就是将运用最广泛的一些数据结构实现出来

常用的数据结构：数组、链表、树、栈、队列、集合、映射表等

这些容器分为序列式容器和关联式容器两种：

• 序列式容器：强调值的排序，序列式容器中的每个元素均有固定的位置
• 关联式容器：二叉树结构，各元素之间没有严格的物理上的顺序关系

算法：用来解决问题的方法

有限的步骤，解决逻辑或数学上的问题，这门科学叫做算法（Algorithms）

算法分为：质变算法和非质变算法

质变算法：指运算过程中会更改区间内的元素的内容，例如：拷贝、替换、删除等

非质变算法：指运算过程中不会改变区间内的元素内容，例如：查找、计数、遍历、寻找极值等

迭代器：容器和算法之间的粘合剂

提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式

每个容器都有自己专属的迭代器

迭代器的使用非常类似于指针，初学阶段我们可以将迭代器理解为指针

迭代器的种类：

种类	功能	支持运算
输入迭代器	对数据的只读访问	只读，支持++、==、！=
输出迭代器	对数据的只写访问	只写，支持++
前向迭代器	读写操作，并能向前推进迭代器	读写，支持++、==、！=
双向迭代器	读写操作，并能向后和向前操作	读写，支持++、--
随机访问迭代器	读写操作，可以以跳跃的方式访问任何数据，是功能最强的迭代器	读写、支持++、--、[n]、-n、<、<=、>、>=

常用的容器中迭代器种类为双向迭代器和随机访问迭代器

2.5. 容器算法迭代器初识

了解STL中容器、算法、迭代器的概念之后，我们利用代码感受STL的魅力

STL中最常用的容器为vector，可以理解为数组，下面我们将学习如何向这个容器中插入数据，并遍历这个容器

2.5.1. vector存放内置数据类型

容器：vector

算法：for_each

迭代器：vector<int>::iterator

示例：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

//vector容器存放内置数据类型
void MyPrint(int val)
{
    cout << val << endl;
}

void Test01()
{
    //创建一个vector容器（类似数组），存放int类型的数据
    vector<int> v;

    //向容器中插入数据
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);

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

    //第一种遍历方式
    vector<int>::iterator it_begin = v.begin();  //起始迭代器，作为指针指向容器中的第一个元素
    vector<int>::iterator it_end = v.end();  //结束迭代器，作为指针指向容器中最后一个元素的下一个位置
    
    while(it_begin != it_end)
    {
        cout << *it_begin << endl;
        it_begin++;
    }

    cout << "----------------------------------------" << endl;

    //第二种遍历方式（常用）
    for(vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << endl;
    }

    cout << "----------------------------------------" << endl;

    //第三种遍历方式，利用STL提供的遍历算法
    for_each(v.begin(), v.end(), MyPrint);  

    // for_each 算法的底层代码如下：
    // template<typename _InputIterator, typename _Function>
    // _GLIBCXX20_CONSTEXPR
    // _Function
    // for_each(_InputIterator __first, _InputIterator __last, _Function __f)
    // {
    //   // concept requirements
    //   __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    //   __glibcxx_requires_valid_range(__first, __last);
    //   for (; __first != __last; ++__first)
	// __f(*__first);
    //   return __f; // N.B. [alg.foreach] says std::move(f) but it's redundant.
    // }

}

int main()
{
    Test01();

    return 0;
}


输出：
---------------------------------------------------------------------------------
10
20
30
40
----------------------------------------
10
20
30
40
----------------------------------------
10
20
30
40

2.5.2.我遇到的问题

在查看for_each文件中的源码时（在文件stl_algo.h中），不小心删除了stl_algo.h文件中的源码，还智障的点了保存，再次返回代码界面for_each代码就报错了，因为他找不到原本的标准库文件，而且再次查看for_each源码也查看不了，一度很绝望。

解决方案其实很简单，我的错误操作就是更改了C++标准库，当涉及到stl_algo.h中的函数调用的时候，找不到对应的底层代码，自然报错，stl_algo.h 头文件是 C++ 标准库的一部分。一旦这些文件被修改，最直接的解决办法是重新安装或修复相关的 C++ 标准库。具体解决办法如下：

1. 确定你的编译器版本

首先，需要确认你使用的 C++ 编译器类型，常见的有 g++（GNU 编译器）或 clang++（LLVM 编译器）。可以通过运行以下命令来查看当前使用的是哪个编译器及其版本：

g++ --version

我是g++11.4版本

2.打开终端，并使用以下命令重新安装 g++-11：

sudo apt update
sudo apt install --reinstall g++-11

这个命令会强制重新安装 g++-11，确保所有与该版本相关的文件都被重置到初始状态。

3.重新安装 libstdc++-11-dev

libstdc++-11-dev 包含了 C++ 标准库的开发文件，对于编译器来说是必须的。通过以下命令来重新安装它：

sudo apt install --reinstall libstdc++-11-dev

这将确保所有标准库的头文件和库文件都被重置，恢复到安装时的原始状态。

2.5.3. vector存放自定义数据类型

学习目标：vector中存放自定义数据类型，并打印输出

示例：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

//vector容器中存放自定义数据类型
class Person
{
public:
    Person(string name, int age)
    {
        this->m_name = name;
        this->m_age = age;
    }

    string m_name;
    int m_age;
};

void Test01()
{
    vector<Person> v;

    Person p1("aaa", 10);
    Person p2("bbb", 20);
    Person p3("ccc", 30);
    Person p4("ddd", 40);
    Person p5("eee", 50);

    //向容器中添加数据
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    v.push_back(p5);

    //遍历容器中的数据
    for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    {
        //*it（即解引用）得到的是vector<>中的数据类型，在本例中为Person数据类型
        // 方式一：
        cout << "姓名：" << (*it).m_name << " 年龄：" << (*it).m_age << endl;
        // 方式二：
        cout << "姓名：" << it->m_name << " 年龄：" << it->m_age << endl;
    }
}

//vector容器中存放自定义的数据类型-指针
void Test02()
{
    vector<Person*> v;

    Person p1("aaa", 100);
    Person p2("bbb", 200);
    Person p3("ccc", 300);
    Person p4("ddd", 400);
    Person p5("eee", 500);

    //向容器中添加数据
    v.push_back(&p1);
    v.push_back(&p2);
    v.push_back(&p3);
    v.push_back(&p4);
    v.push_back(&p5);

    //遍历容器
    for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
    {
        //*it（即解引用）得到的是vector<>中的数据类型，在本例中为Person*数据类型
        // cout << "姓名：" << (*it).m_name << " 年龄：" << (*it).m_age << endl;  //报错：表达式必须具有类类型，但它具有类型 "Person *"
        cout << "姓名：" << (*it)->m_name << " 年龄："<< (*it)->m_age << endl;
    }
}

int main()
{
    Test01();
    Test02();

    return 0;
}


输出：
---------------------------------------------------------------------------------
姓名：aaa 年龄：10
姓名：aaa 年龄：10
姓名：bbb 年龄：20
姓名：bbb 年龄：20
姓名：ccc 年龄：30
姓名：ccc 年龄：30
姓名：ddd 年龄：40
姓名：ddd 年龄：40
姓名：eee 年龄：50
姓名：eee 年龄：50
姓名：aaa 年龄：100
姓名：bbb 年龄：200
姓名：ccc 年龄：300
姓名：ddd 年龄：400
姓名：eee 年龄：500

2.5.4. vector容器嵌套容器

学习目标：容器中嵌套容器（类似二维数组），将所有数据进行遍历并输出

示例：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

//vector容器嵌套容器
void Test01()
{
    vector<vector<int>> v;

    //创建小容器
    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 + 2);
        v3.push_back(i + 3);
        v4.push_back(i + 4);
    }

    //将小容器放入到大容器中
    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);
    v.push_back(v4);

    //通过大容器，把所有数据遍历一遍
    for(vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
    {
        //*it指代容器类型数据 vector<int>
        for(vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
        {
            //*vit指代整型数据 int
            cout << *vit << " ";
        }
        cout << endl;
    }
}


int main()
{
    Test01();

    return 0;
}


输出：
---------------------------------------------------------------------------------
1 2 3 4 
2 3 4 5 
3 4 5 6 
4 5 6 7