C++面向对象（OOP）编程-STL详解（vector）

本文主要介绍STL六大组件，并主要介绍一些容器的使用。

[1 泛型编程](#1 泛型编程)

[2 C++STL](#2 C++STL)

[3 STL 六大组件](#3 STL 六大组件)

[4 容器](#4 容器)

[4.1 顺序性容器](#4.1 顺序性容器)

[4.1.1 顺序性容器的使用场景](#4.1.1 顺序性容器的使用场景)

[4.2 关联式容器](#4.2 关联式容器)

[4.2.1 关联式容器的使用场景](#4.2.1 关联式容器的使用场景)

[4.3 容器适配器](#4.3 容器适配器)

[4.3.1 容器适配器的使用场景](#4.3.1 容器适配器的使用场景)

[5 具体容器的使用和剖析](#5 具体容器的使用和剖析)

[5.1 vector（向量）](#5.1 vector（向量）)

[5.1.2 vector扩容](#5.1.2 vector扩容)

1 泛型编程

泛型编程是一种代码重用技术，尽可能的将代码写的抽象和通用，将算法从数据结构抽象出来，以便适配多种多样的数据结构，C++的模板编程就是一种泛型编程技术。

2 C++STL

STL（Standard Template Library），即标准模板库，是一个高效的C++程序库。

被容纳于C++标准程序库（C++ Standard Library）中，是ANSI/ISO C++标准中最新的也是极具革命性的一部分。

包含了诸多在计算机科学领域里常用的基本数据结构和基本算法。为广大C++程序员们提供了一个可扩展的应用框架，高度体现了软件的可复用性。

从逻辑层次来看，在STL中体现了泛型化程序设计的思想（generic programming）

在这种思想里，大部分基本算法被抽象，被泛化，独立于与之对应的数据结构，用于以相同或相近的方式处理各种不同情形。

从实现层次看，整个STL是以一种类型参数化（type parameterized）的方式实现的,基于模板(template)。

简单理解：

STL 的基本观念就是将数据和操作分离。数据由容器进行管理，操作则由算法进行，而迭代器在两者之间充当粘合剂，使任何算法都可以和任何容器交互运作。

3 STL 六大组件

STL的组成	含义
容器	一些封装数据结构的模板类，例如 vector 向量容器、list 列表容器等。
算法	STL 提供了非常多（大约 100 个）的数据结构算法，它们都被设计成一个个的模板函数，这些算法在 std 命名空间中定义，其中大部分算法都包含在头文件 <algorithm> 中，少部分位于头文件 <numeric> 中。
迭代器	在 C++ STL 中，对容器中数据的读和写，是通过迭代器完成的，扮演着容器和算法之间的胶合剂。
函数对象	如果一个类将 () 运算符重载为成员函数，这个类就称为函数对象类，这个类的对象就是函数对象（又称仿函数）。
适配器	可以使一个类的接口（模板的参数）适配成用户指定的形式，从而让原本不能在一起工作的两个类工作在一起。值得一提的是，容器、迭代器和函数都有适配器。
内存分配器	为容器类模板提供自定义的内存申请和释放功能，由于往往只有高级用户才有改变内存分配策略的需求，因此内存分配器对于一般用户来说，并不常用。简称分配器。
[STL 六大组件]

4 容器

所谓容器，就是可以承载，包含元素的一个器件，它是STL六大组件之一，是容器、算法、迭代器中最重要也是最核心的一部分。

4.1 顺序性容器

顺序性容器就是将一组具有相同类型的元素以严格的线性形式组织起来。顺序性容器的存储结构有顺序存储和链式存储。

具体的顺序性容器如下：

容器	简介说明
vector	可变大小数组。相当于数组，可动态构建，支持随机访问，无头插和尾插，仅支持inset插入，除尾部外的元素删除比较麻烦。但使用最为广泛。
deque	双端队列。支持头插、删，尾插、删，随机访问较vector容器来说慢,但对于首尾的数据操作比较方便
list	双向循环链表。使用起来很高效，对于任意位置的插入和删除都很快，在操作过后，以后指针、迭代器、引用都不会失效
forward_list	单向链表。只支持单向访问，在链表的任何位置进行插入/删除操作都非常快
array	固定数组。vector的底层即为array数组，它保存了一个以严格顺序排列的特定数量的元素

4.1.1 顺序性容器的使用场景

一般大多数的题目都可以使用vector容器，除非有特定需求使用其他容器更加合理方便；

如果需要在一串数字的头尾进行操作，偏向deque，对于较中间的元素操作，不推荐；

对于中间的元素插入或删除，可采用forward_list（单向链表）或list（双向链表），不需要移动元素，只需改变相关结点的指针域即可；

一个例子：

cpp 复制代码

#include <iostream>
#include <vector>

using namespace std;

// vector容器大小:
// 1 2 4 8 16 32
// vector 容器大小的增长是以2的倍数
int main(int argc, char *argv[])
{

    vector<int> v1;

    for (int i = 0;i < 17;i++)
        v1.push_back(i);

    cout << v1[3] << endl;
    cout << v1.size() << endl;
    cout << v1.capacity() << endl;


    return 0;
}

运行结果：

4.2 关联式容器

关联式容器每一个元素都有一个键值（key），对于二元关联容器，还拥有实值（value）容器中的元素顺序不能由程序员来决定，有set（集合）和map（映射）这两大类，它们均是以RB-Tree（red-black tree，红黑树）为底层架构。

具体的关联式容器如下：

容器	简介说明
set/mutliset	集合/多重集合。对于set，在使用insert插入元素时，已插入过的元素不可重复插入，这正好符合了集合的互异性，在插入完成显示后，会默认按照升序进行排序，对于multiset，可插入多个重复的元素
map/mutlimap	映射/多重映射。二者均为二元关联容器（在构造时需要写两个参数类型，前者对key值，后者对应value值），因为有两个参数，因此在插入元素的时候需要配合对组pair进行插入，具体见深入详解

4.2.1 关联式容器的使用场景

如果只负责查找内容，具体到某个单位，使用场景比如对手机游戏的个人的计分的存储，可以使用set或mutliset。

如果需要同时放入容器的数据不止一个，并且是不同类型，比如一个为整型int,一个为string字符串型，就可以考虑使用map或mutlimap。

4.3 容器适配器

容器适配器是一个封装了序列容器的一个类模板=，它在一般的序列容器的基础上提供了一些不同的功能。之所以称为容器适配器，是因为它是适配容器来提供其它不一样的功能。通过对应的容器和成员函数来实现我们需要的功能。

具体的容器适配器如下：

容器	简介说明
stack	堆栈。其原理是先进后出（FILO），其底层容器可以是任何标准的容器适配器，默认为deque双端队列
queue	队列。其原理是先进先出（FIFO），只有队头和队尾可以被访问，故不可有遍历行为，默认也为deque双端队列
pirority_queue	优先队列。它的第一个元素总是它所包含的元素中优先级最高的，就像数据结构里的堆，会默认形成大堆，还可以使用仿函数来控制生成大根堆还是生成小根堆，若没定义，默认使用vector容器

4.3.1 容器适配器的使用场景

（1）对于 stack 堆栈，在我们日常生活中类似于坐地铁、电梯；

（2）对于 deque 队列，在我们日常生活中类似于排队打饭；

（3）对于 pirority_queue，因为其本质是堆，可以考虑解决一些贪心问题；

5 具体容器的使用和剖析

5.1 vector（向量）

对于vector容器，它的数据结构与数组非常类似，但是他们之间的不同之处是数组是静态空间，一旦配置了就不能更改，vector却可以进行动态分配，随着元素的插入和删除，内部的空间也会灵活变动，就和C语言中的malloc和C++中的new是一个道理，不用害怕空间不足而一开始就定义一个很大的数组，节省了内存空间。容器的大小是可以改变的。vector扩容是2的倍数。

一些例子：

cpp 复制代码

#include <iostream>
#include <vector>

/*
 * 线性表是一种逻辑结构，按照存储结构可以分为顺序表和链表
 *
 * 
*/
/* vector 本质上是一个动态变长数组，顺序表，连续的存储空间，访问的时间复杂度为O(1),对于尾部元素的插入和删除时间复杂度都是常量级别的
 * vector 也是一个类模板，vector底层本质就是一个顺序表，它是一个可变长的数组，采用连续存储的空间来存储数据，它的元素类型也可以是任意的内置类型或者自定义类型。
 * 对于vector的扩容机制，Linux一般是以2的倍数增加，VS一般是以1.5的倍数增加，增加快的性能会比较好，但是对空间的浪费会增大；
 * vector扩容是开辟一段新的空间，将旧的数据拷贝到新的空间
*/
/*
 * 扩容 vec.resize(n)  vec.reserve(n)
*/

int main(int argc, char *argv[])
{
    
    std::vector<int> vec = {1, 2, 3, 4, 5};
    // vec.begin()+2 代表从第三个元素开始，vec。begin()代表从第一个元素开始
    std::vector<int> vec1(vec.begin()+2,vec.end()); // = vec
    std::vector<int> vec2(vec); // = vec
    std::vector<int> vec3(4); // [0,0,0,0]
    std::vector<int> vec4(2,4); // [4,4]

    // vec.erase(vec.begin()+1); // 删除第二个元素

    vec.erase(vec.begin(),vec.begin()+1);//删除[1,3) 删除两个元素


    for (auto i : vec1) {
        std::cout << i << " ";
        std::cout << "*******" << std::endl;
    }
    vec.push_back(18); //在尾部插入一个元素
    std::cout << "Front1: " << vec.front() << std::endl;
    std::cout << "Back1: " << vec.back() << std::endl;
    vec.pop_back(); // 弹出尾部的元素
    vec.insert(vec.begin()+4,3,99);
    for (int i = 0;i < vec.size();i++)
    {
        // std::cout << "vec(" << i << "): " << vec[i] << std::endl;
        std::cout << "vec(" << i << "): " << vec.at(i) << std::endl;
        
    }

    for (int i = 0;i < vec.size();i++)
    {
        std::cout << i << " : " << vec.data()[i] << std::endl;
    }
    std::cout << "*********" << std::endl;

    std::vector<int>::iterator it;
    for (it = vec.begin();it != vec.end();it++)
    {
        std::cout << " " << " : " << *it << std::endl;
    }
    std::cout << "*********" << std::endl;

    for (auto it = vec.begin();it != vec.end();it++)
    {
        std::cout << " " << " : " << *it << std::endl;
    }
    std::cout << "*********" << std::endl;
    // 返回常量迭代器的元素
    for (auto it = vec.cbegin();it != vec.cend();it++)
    {
        std::cout << " " << " : " << *it << std::endl;
    }
    std::cout << "*********" << std::endl;

    // 逆序返回常量迭代器的元素
    for (auto it = vec.rbegin();it != vec.rend();it++)
    {
        std::cout << " " << " : " << *it << std::endl;
    }
    std::cout << "*********" << std::endl;

    std::cout << "size: " << vec.size() << " Capacity: " << vec.capacity() << std::endl;

    vec.clear();
    /* vec.resize(n) resize的扩容不会改变容器中原来的值，这里默认对扩容的部分初始化为0
     * n > capacity 时 ，可以对vector进行扩容,此时 size = capacity = n,n 为任意的大于原来capacity的值
     * n < capacity 时，不能对vector进行扩容，此时 size = n,但是 capacity 仍然与原来的capacity 相等
     * vec.reserve(n) 是指将容器的容量改为n,容器中的数据的个数不做改变也就是，不会对vec.size() 做改变
     * n > capacity 时 ，可以仅仅对容器进行扩容，此时size保持不变，capacity = n
     * n < capacity 时 ，不做任何的改变，对size 和capacity没有任何影响
     * vec.assign(n,0) assign的扩容会改变容器中原来的值，第二个参数就是需要改变后的值
     * n > capacity 时 ，可以对vector进行扩容,此时 size = capacity = n,n 为任意的大于原来capacity的值
     * n < capacity 时，不能对vector进行扩容，此时 size = n,但是 capacity 仍然与原来的capacity 相等
     * 总之，对于vector容器只能增大其容量，不能减小其容量
    */
    vec.push_back(12);
    vec.push_back(13);
    
    // vec.resize(13);
    vec.assign(13,0);
    // vec.reserve(13);  // 仅仅改变capacity 的大小
    std::cout << "Resize size: " << vec.size() << " Capacity: " << vec.capacity() << std::endl;

    std::cout << "size: " << vec.size() << " vec = [ ";
    for (int i = 0;i < vec.size();i++)
    {
        std::cout << vec[i] << " ";
    }
    std::cout << " ] " << std::endl; // vec.assign(13，0) 的输出结果： size: 13 vec = [ 0 0 0 0 0 0 0 0 0 0 0 0 0  ]  vec.resize(13) 的输出结果： size: 13 vec = [ 12 13 0 0 0 0 0 0 0 0 0 0 0  ] 

    for (int i = 0;i < 10;i++)
    {
        vec.push_back(i);
    } // 需要对vector进行扩容，一般扩容是2的指数级别的
    
    std::cout << "After clear size: " << vec.size() << " Capacity: " << vec.capacity() << std::endl;

    if (vec.empty())
    {
        std::cout << "Vec is empty!" << std::endl;
    }

    std::vector<int> vecT[3];// vector 定义二维数组

    for (int i = 0;i < 3;i++)
    {
        vecT[i].push_back(i);
        std::cout << "vecT" << i << " size: " << vecT[i].size() << std::endl;
    }

    std::vector<std::vector<int>> vecT1;// vector 定义二维数组
    vecT1.resize(5);//5 行
    for (int i = 0;i < 5;i++)
    {
        vecT1[i].resize(10);//10 列
    }
    for (int i = 0;i < vecT1.size();i++)
    {
        for (int j = 0;j < vecT1[i].size();j++)
        {
            vecT1[i][j] = i*j;
        }
    }

    for (int i = 0;i < vecT1.size();i++)
    {
        for (int j = 0;j < vecT1[i].size();j++)
        {
            std::cout << vecT1[i][j] << " ";
        }
    }
    std::cout << std::endl;
    

    return 0;
}

5.1.2 vector扩容

（1）vec.resize(n)

vec.resize(n) resize的扩容不会改变容器中原来的值，这里默认对扩容的部分初始化为0

n > capacity 时，可以对vector进行扩容,此时 size = capacity = n,n 为任意的大于原来capacity的值

n < capacity 时，不能对vector进行扩容，此时 size = n,但是 capacity 仍然与原来的capacity 相等

（2）vec.reserve(n)

vec.reserve(n) 是指将容器的容量改为n,容器中的数据的个数不做改变也就是，不会对vec.size() 做改变

n > capacity 时，可以仅仅对容器进行扩容，此时size保持不变，capacity = n

n < capacity 时，不做任何的改变，对size 和capacity没有任何影响

（3）vec.assign(n,0)

vec.assign(n,0) assign的扩容会改变容器中原来的值，第二个参数就是需要改变后的值

n > capacity 时，可以对vector进行扩容,此时 size = capacity = n,n 为任意的大于原来capacity的值

n < capacity 时，不能对vector进行扩容，此时 size = n,但是 capacity 仍然与原来的capacity 相等

总之，对于vector容器只能增大其容量，不能减小其容量