C++梁哥笔记day22 | 我的日常分享

C++梁哥笔记day22

发表于2021-01-21更新于2021-01-21字数统计3.2k阅读时长39分

一、STL概述

长久以来，软件界一直希望建立一种可重复利用的东西，以及一种得以制造出“可重复运用的东西”的方法，让程序员的心血不止于时间的迁移，人事异动而烟消云散，从函数、类别、函数库、类别库、各种组件，从模块化设计到面向对象，为的就是复用性的提升。

复用性必须建立在某种标准之上。但是在许多环境下，就连软件开发最基本的数据结构和算法都未能有一套标准。大量程序员被迫从事大量重复的工作，竟是为了完成前人已经完成而手上并未拥有的程序代码，这不仅是人力资源的浪费，也是挫折与痛苦的来源。

为了建立数据结构和算法的一套标准，并且降低他们之间的耦合关系，以提升各自的独立性、弹性、交互操作性(相互合作性)，于是诞生了STL。

1.1 STL基本概念

STL(Standard Template Library,标准模板库)，是惠普实验室开发的一系列软件的统称。现在主要出现在C++中，但是在引入C++之前该技术已经存在很长时间了。STL从广义上分为：容器(container)、算法(algorithm)、迭代器(iterator)，容器和算法之间通过迭代器进行无缝连接。STL几乎所有的代码都采用了模板类或者模板函数，这相比传统的由函数和类组成的库来说提供了更好的代码重用机会。STL标准模板库，在我们C++标准程序库中隶属于STL的找到了80%以上。

SLT三大组件：容器(container)、算法(algorithm)、迭代器(iterator)

image-20210121174858855

1.2 STL六大组件简介

STL提供了六大组件，彼此之间可以组合套用，这六大组件分别是：容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器。

  • 容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据，从实现的角度来看，STL容器是一种class template(类模板)。

  • 算法：各种常用算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种function template(函数模板)。

  • 迭代器：扮演了容器与算法之间的胶合剂，共有五种类型，从实现的角度来看，迭代器是一种将operator*、operator->、operator++、operator–等指正相关操作予以重载的class template。所有的STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。原生指针（native pointer）也是一种迭代器。

  • 仿函数：行为类似函数，可作为算法的某种策略。从实现角度来看，仿函数是一种重载了operator()的class 或者 class template。

  • 适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。（可以理解为usb拓展坞将电脑一个usb口拓展为多个usb口；为算法提供更多的参数接口）

  • 空间配置器：管理容器和算法的内存空间。负责空间的配置和管理；从实现角度看，配置器是一个实现了动态空间配置、空间管理、空间释放的class template。

STL六大组件的交互关系，容器通过空间配置器取得数据存储空间，算法通过迭代器存储容器中的内容，仿函数可以协助算法完成不同的策略的变化，适配器可以修饰仿函数。

1.3 STL的优点

STL是C++的一部分，因此不用额外安装什么，它被内建在你的编译器之内。

STL的一个重要特性是将数据和操作分离。数据由容器类别加以管理，操作则由可定制的算法定义。迭代器在两者之前充当“粘合剂”，以使算法可以和容器交互运作，程序员可以不用思考STL具体的实现过程，只要能熟练使用STL就OK了。这样他们就可以把精力放在程序开发的别的方面。STL具有高可重用性，高性能，高移植性，跨平台的优点。

  • 高可重用性：STL中几乎所有的代码都采用了模板类和模板函数的方式实现，这相比传统的由函数和类组成的库来说提供了更好的代码重用机会。
  • 高性能：如map可以高效地从十万条记录里面查找出指定的记录，因为map是采用红黑树的变体实现的。
  • 高移植性：如在项目A上用STL编写的模块，可以直接移植到项目B上。

image-20210121203522393

STL之父Alex Stepanov 亚历山大·斯特潘诺夫（STL创建者）

二、STL三大组件

2.1 容器

容器，置物之所以也。研究数据的特定排列方式，以利于搜索或排序或其它特殊目的，这门学科我们称为数据结构。大学信息类相关专业里面，与编程最有之间关系的学科，首推数据结构与算法。几乎可以说，任何特定的数据结构都是为了实现某种特定的算法。STL容器就是将运用最广泛的一些数据结构实现出来。

常用的数据结构：数组（array）、链表（list）、树（tree）、栈（stack）、队列（queue）、集合（set）、映射表（map），根据数据在容器中的排列特性，这些数据分为序列式容器和关联式容器两种。序列式容器强调值得排序，序列式容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。Vector容器、Deque容器、List容器等。关联式容器是非线性的树结构，更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存置入容器时的逻辑顺序。关联式容器另一个显著特点是：在值中选择一个值作为关键字key，这个关键字对值起到索引的作用，方便寻找。Set/multiset容器、Map/multimap容器。

容器可以嵌套容器。

image-20210121204743349

2.2 算法

算法，问题之解法也。以有限的步骤，解决逻辑或数学上的问题，这门学科我们叫做算法。广义而言，我们所编写的每个程序都是一个算法，其中的每个函数也都是一个算法，毕竟它们都是用来解决或大或小的逻辑问题或数学问题。STL收录的算法经过了数学上的效能分析与证明，是极具有复用价值的，包括常用的排序，寻找等等。特定的算法往往搭配特定的数据结构，算法与数据结构相辅相成。

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

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

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

2.3 迭代器

迭代器（iterator）是一种抽象的设计概念，现实程序语言中并没有直接对应于这个概念的实物。在《C++ primer》一书中提供了23中设计模式的完整描述，其中iterator模式定义如下：提供一种方法，是使之能够依序寻访某个容器所含的各个元素，而无需暴露该容器的内部表示方式。

迭代器的设计思维是STL的关键所在，STL的中心思想在于将容器和算法分开，彼此独立设计，最后在一贴胶合剂将它们撮合在一起。从技术的角度来看，容器和算法的泛型化并不困难，C++的class template和function template 可分别达成目标，如何设计出两者之间良好的胶合剂，才是大难题。

迭代器的种类：
输入迭代器 提供对数据的只读访问 只读，支持++、==、!=
输入迭代器 提供对数据的只写访问 只写，支持++
前向迭代器 提供读写操作，并能向前推进迭代器 读写，支持++、==、!=
双向迭代器 提供读写操作，并能向前和向后操作 读写，支持++、–
随机访问迭代器 提供读写操作，并能以跳跃的方式访问容器的任意数据，是功能最强的迭代器 读写，支持++、–、[n]、-n、<、<=、>、>=

2.4 迭代器的案例：（vector容器的for循环遍历）

image-20210121211634495

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void test01(){
    //单端动态数组vector类模板
    vector<int> v;//v就是一个具体的vector容器

    //push_back 尾部插入
    v.push_back(100);
    v.push_back(200);
    v.push_back(300);
    v.push_back(400);

    //访问数据
    //定义一个迭代器存储 v的起始迭代器
    vector<int>::iterator beginIt = v.begin();
    //定义一个迭代器存储 v的结束迭代器
    vector<int>::iterator endIt = v.end();

    //for循环遍历
    for(;beginIt != endIt;beginIt++){
        //对迭代器取* 代表的是容器的元素
        //准确来说是<>里面的类型 所以这里对迭代器取* 是int类型
        cout<<*beginIt<<" ";
    }
    cout<<endl;

    //for循环遍历方式二（推荐）
    for(vector<int>::iterator it = v.begin();it != v.end();it++){
        cout<<*it<<" ";
    }
    cout<<endl;

    //使用STL提供的算法来遍历容器（包含头文件 algorithm）
    //for_each 从容器的起始到结束 逐个元素取出  传给第三个参数函数的形参
    void myPrintInt(int val);
    for_each(v.begin(),v.end(),myPrintInt);
    cout<<endl;

}
void myPrintInt(int val){
    cout<<val<<" ";
}

int main(int argc, char *argv[])
{
    test01();
    return 0;
}

运行结果：

image-20210121214953856

2.5 for_each()详解

代码实现：

image-20210121215850665

1
2
3
4
5
6
7
8
9
10
11
12
// FUNCTION TEMPLATE for_each
template <class _InIt, class _Fn>
_Fn for_each(_InIt _First, _InIt _Last, _Fn _Func) { // perform function for each element [_First, _Last)
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst) {
        _Func(*_UFirst);
    }

    return _Func;
}

2.6 vector容器存放自定义数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Person{
private:
    string name;
    int age;
public:
    friend void myPrintPerson(Person &ob);
    Person(string name,int age){
        this->name = name;
        this->age = age;
    }
};
void myPrintPerson(Person &ob){
    cout<<ob.name<<" "<<ob.age<<endl;
}
void test02(){
    Person ob1("lucy",18);
    Person ob2("bob",17);
    Person ob3("mick",23);
    Person ob4("xiaohua",20);

    vector<Person> v;
    v.push_back(ob1);
    v.push_back(ob2);
    v.push_back(ob3);
    v.push_back(ob4);

    for_each(v.begin(),v.end(),myPrintPerson);
}

运行结果：

image-20210121221650347

2.7容器嵌套容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
void fun2(int &val){
    cout<<val<<",";
}
void fun1(vector<int> &v){
    for_each(v.begin(),v.end(),fun2);
    cout<<endl;
}
void test03(){
    vector<int> v1;
    vector<int> v2;
    vector<int> v3;

    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);
    v2.push_back(100);
    v2.push_back(200);
    v2.push_back(300);
    v2.push_back(400);
    v3.push_back(1000);
    v3.push_back(2000);
    v3.push_back(3000);
    v3.push_back(4000);

    //定义一个容器存储v1 v2 v3
    vector<vector<int>> v;
    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);

    //使用for循环遍历
    for(vector<vector<int>>::iterator it = v.begin();it!=v.end();it++){
        //*it == vector<int>
        for(vector<int>::iterator midit = (*it).begin();midit!=(*it).end();midit++){
            //*midit == int
            cout<<*midit<<" ";
        }
        cout<<endl;
    }

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

    //使用for_each 遍历
    for_each(v.begin(),v.end(),fun1);
}

运行结果：

image-20210121222900820