STL——vector

• STL库中的vector需要引入头文件：

#include <vector>

• 类模板原型：

template < class T, class Alloc = allocator<T> > class vector; // generic template

模板参数

• T：元素的类型
• Alloc：vector底层存储数据的内存是从空间配置器申请的，如果需要可以⾃⼰实现内存池，传给第二个参数

2 vector使用

2.1 vector的定义

2.1.1 无参构造

vector();

vector<int> v; //定义了一个名为a的一维数组,数组存储int类型数据

2.1.2 构造并初始化N个Val

vector(size_t n, const T& val = T())

vector<int> v(n); //定义一个长度为n的数组，初始值默认为0，下标范围[0, n - 1] 
vector<int> v(n, 10); //v[0] 到 v[n - 1]所有的元素初始值均为10 
vector<Test> v(n); //定义一个长度为n的数组，将调用Test的构造函数初始化，下标范围[0, n - 1]

模板参数：

• n：初始容器大小
• val：对于内置类型，会进行默认初始化，对于自定义类型，会调用相对应的构造函数进行初始化

2.1.3 拷贝构造

vector (const vector& x);

vector<int> v1(10); 
vector<int> v2(v1); //两个数组中的类型必须相同,v1和v2都是长度为10，初始值都为0的数组

2.1.4 使用迭代器初始化构造

类模板的成员函数，也可以是一个函数模板。这样设计的好处在于不限于只使用vector的容量进行初始化，还可以使用其他容器进行初始化。比如：list、string、deque等

template <class InputIterator> 
vector (InputIterator first, InputIterator last);

vector<int> v1; 
list<int> l1; 
deque<int> d1; 

vector<int> v2(v1.begin(),v1.end()); 
vector<int> v3(l1.begin(),l1.end()); 
vector<int> v4(d1.begin(),d1.end());

2.1.5 使用大括号初始化构造

vector (initializer_list<T> il);

首先要明确，这种初始化方式只支持C++11以后的标准

initializer_list是C++11新加入的一种容量，这个容器支持迭代器访问。它的原理与使用大括号创建数组很相似cplusplus.com/reference/initializer_list/initializer_list/

auto il = {1,2,3,4,5}; 
int arr[] = {1,2,3,4,5};

//vector使用大括号初始化的原理就是，先将其转化为initializer_list容器，然后调用相应的构造函数进行初始化
vector<int> v{1, 2, 3, 4, 5}; //数组v中有五个元素，数组长度就为5

2.2 vector的迭代器

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装

注意：

• end() 返回的是最后一个元素的后一个位置的地址，不是最后一个元素的地址，所有STL容器均是如此

vector<int> v{1,2,3,4,5,6,7,8,9}; 
for(auto it = v.begin(); it != v.end(); it++) 
{ 
    cout << *it << endl; 
} 

for(auto it = v.rbegin(); it != v.rend(); it++) 
{ 
    cout << *it << endl; 
}

2.2.1 const 迭代器

当我们想创建被const修饰的vector容器迭代器时，不可以直接在迭代器前加const

vector<int> v; 
const vector<int>::iterator it = v.begin();

以上的写法是不可以的，他不能达到it所指向的内容不能被修改,实际是it它本身不可以被修改

它会转换为：

int* const it = v.begin();

示例：

int main()
{
    vector<int> v;
    v.push_back(1);
    cout << *v.begin() << endl;
    const vector<int>::iterator it = v.begin();
    *it = 2;
    cout << *v.begin() << endl;
    return 0;
}

因此这里需要使用 const_iterator，const_iterator 就是 const T* 的重定义

typedef const T* const_iterator;

vector<int> ::const_iterator it2 = v.begin(); 
*it2 = 2;

此时的迭代器就是指向的内容不可以被改变

2.3 vector的空间增长

resize的增长逻辑：

1. 小于当前容器元素个数：删除至n个元素
2. 大于当前容器元素个数，小于当前容器容量：填充指定元素
3. 大于当前容器容量：扩容至n个元素，并且填充指定元素

reserver的增长逻辑（不同平台会有差异）：

1. 大于当前容量就扩容
2. 小于当前容量默认不改变容量

2.4 vector的增删改查