【C++】STL常用容器：vector（详解及模拟实现）
前言：
本篇内容主要介绍vector的使用，以及vector的深度剖析及模拟实现。
上篇博客：【C++】STL常用容器：string类（详解及模拟实现）
文章目录
-
-
- 1. vector的介绍及使用
-
- 1.1 vector的介绍
- 1.2 vector的使用
-
- 1.2.1 vector的定义（构造函数）
- 1.2.2 vector iterator的使用
- 1.2.3 vector空间增长增长问题
- 1.2.4 vector的增删查改
- 1.2.5 vector迭代器失效问题（重点）
- 2. vector深度剖析及模拟实现
-
- 2.1 std::vector的核心框架接口的模拟实现
- 2.2 使用memcpy导致的浅拷贝问题
-
1. vector的介绍及使用
1.1 vector的介绍
学习工具：C++官方文档 -> vector的文档介绍
关于vector有以下需要注意的要点：
vector是表示可变大小数组的序列容器。- 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
- 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入的时候，为了增加存储空间，这个数组需要被重新分配大小。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大
小。- vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
- 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
- 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好
学习vector，实际上还是按照SLT学习的三个境界：能用，明理，能扩展
1.2 vector的使用
学习vector必须要学会查看文档：vector的文档介绍，这里面有许多它的接口，在往后的学习过程中，要时常查阅该文档，增加对常用接口的理解与记忆。下面主要介绍常用的接口：
1.2.1 vector的定义（构造函数）
| (constructor)构造函数声明 | 接口说明 |
|---|---|
vector()（重点） |
无参构造 |
| vector (size_type n, const value_type& val = value_type() ) | 构造并初始化n个val |
vector(const vector& v)（重点） |
拷贝构造 |
| template < class InputIterator>; （模板参数） vector (InputIterator first, InputIterator last) | 使用迭代器进行初始化，可接收其他容器的迭代器区间 |
下面是一段演示代码：（vs2019底下）
// vector的构造
int TestVector1()
{
// constructors used in the same order as described above:
vector<int> v1; // empty vector of ints
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
vector<int> v2(4, 100); // four ints with value 100
for (auto e : v2)
{
cout << e << " ";
}
cout << endl;
vector<int> v3(v2.begin(), v2.end()); // iterating through v2
for (auto e : v3)
{
cout << e << " ";
}
cout << endl;
vector<int> v4(v3); // a copy of v3
for (auto e : v4)
{
cout << e << " ";
}
cout << endl;
// 下面是迭代器初始化的部分
// the iterator constructor can also be used to construct from arrays:
int ints[] = { 16,2,77,29 };
vector<int> v5(ints, ints + sizeof(ints) / sizeof(int));
//迭代器区间可以是其他容器，比如string、list等都可以传递进行构造
cout << "The contents of v5 are:";
for (vector<int>::iterator it = v5.begin(); it != v5.end(); ++it)
cout << *it << " ";
cout << endl;
return 0;
}
运行结果：
1.2.2 vector iterator的使用
| iterator | 接口说明 |
|---|---|
begin() 、end()（重点） |
获取第一个数据的iterator/const_iterator，获取最后一个数据的下一个位置的iterator/const_iterator |
| rbegin()、rend() | 获取最后一个数据位置的reverse_iterator/const_reverse_iterator，获取第一个数据的前一个位置的reverse_ iterator/const_reverse_iterator |
下面是一段演示代码：
// vector的迭代器
void PrintVector(const vector<int>& v)
{
// const对象使用const迭代器进行遍历打印
vector<int>::const_iterator it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
}
void TestVector2()
{
// 使用push_back插入4个数据
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
// 使用迭代器进行遍历打印
vector<int>::iterator it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
// 使用迭代器进行修改
it = v.begin();
while (it != v.end())
{
*it *= 2;
++it;
}
// 使用反向迭代器进行遍历再打印
// vector::reverse_iterator rit = v.rbegin();
auto rit = v.rbegin();
while (rit != v.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
//范围for
for (const auto& e : v)
{
cout << e << " ";
}
cout << endl;
PrintVector(v);
}
运行结果：
1.2.3 vector空间增长增长问题
| 容量空间 | 接口说明 |
|---|---|
| size() | 获取数据个数 |
| capacity() | 获取容量大小 |
| empty() | 判断是否为空 |
resize()（重点） |
改变vector的size，可以用来初始化！ |
reserve()（重点） |
改变vector的capacity |
下面是一段演示代码：
// vector的resize 和 reserve
// reisze(size_t n, const T& val = T())
// 将有效元素个数设置为n个，如果时增多时，增多的元素使用val进行填充
// 注意：resize在增多元素个数时可能会扩容
void TestVector3()
{
vector<int> v;
// set some initial content:
for (int i = 1; i < 10; i++)
v.push_back(i);
cout << "v contains:";
for (size_t i = 0; i < v.size(); i++)
cout << v[i] << " ";
cout << endl;
v.resize(5);
cout << "v contains:";
for (size_t i = 0; i < v.size(); i++)
cout << v[i] << " ";
cout << endl;
v.resize(8, 100);
cout << "v contains:";
for (size_t i = 0; i < v.size(); i++)
cout << v[i] << " ";
cout << endl;
v.resize(12);
cout << "v contains:";
for (size_t i = 0; i < v.size(); i++)
cout << v[i] << " ";
cout << endl;
}
// 往vecotr中插入元素时，如果大概已经知道要存放多少个元素
// 可以通过reserve方法提前将容量设置好，避免边插入边扩容效率低
void TestVectorExpandOP()
{
vector<int> v;
size_t sz = v.capacity();
v.reserve(100); // 提前将容量设置好，可以避免插入过程中多次扩容的消耗
cout << "making bar grow:" << endl;
for (int i = 0; i < 100; ++i)
{
v.push_back(i);
if (sz != v.capacity())
{
sz = v.capacity();
cout << "capacity changed: " << sz << endl;
}
}
}
运行结果：
关于vector的扩容机制：
- capacity()的代码在vs和g++下分别运行会发现，vs下的capacity是按1.5倍增长，g++是按2倍增长。这个问题在面试中会经常出现，此时不要简单的认为vector的增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本的STL，而g++是SGI版本的STL，他们的capacity实现上有所差异！
- reserve只是负责开辟空间，如果确定知道要用多少空间，reserve可以缓解vector多次增容的代价缺陷。
- resize在开辟空间的同时，还会进行初始化，最终可影响size,甚至是影响capacity。
下面是一段测试扩容机制的代码，可于不同编译环境底下运行查看结果：
// 测试vector的默认扩容机制
void TestVectorExpand()
{
size_t sz;
vector<int> v;
sz = v.capacity();
cout << "making v grow:" << endl;
for (int i = 0; i < 100; ++i)
{
v.push_back(i);
if (sz != v.capacity())
{
sz = v.capacity();
cout << "capacity changed: " << sz << endl;
}
}
}
运行结果：
- vs运行结果：vs底下使用的STL基本是用1.5倍方式扩容
making v grow:
capacity changed: 1
capacity changed: 2
capacity changed: 3
capacity changed: 4
capacity changed: 6
capacity changed: 9
capacity changed: 13
capacity changed: 19
capacity changed: 28
capacity changed: 42
capacity changed: 63
capacity changed: 94
capacity changed: 141
- g++运行结果：linux底下使用的STL基本是用2倍方式扩容
making foo grow:
capacity changed: 1
capacity changed: 2
capacity changed: 4
capacity changed: 8
capacity changed: 16
capacity changed: 32
capacity changed: 64
capacity changed: 128
1.2.4 vector的增删查改
| 增删查改 | 接口说明 |
|---|---|
push_back（重点） |
尾插 |
pop_back（重点） |
尾删 |
find（注意） |
查找，它并不是vector的成员函数，它是定义在算法头文件(algorithm)中的一个函数模板 |
| insert | 在pos位置之前插入val |
| erase | 删除pos位置的数据 |
| swap | 交换两个vector的数据空间 |
operator[]（重点） |
[]重载，使vector对象的元素可以像数组一样访问 |
下面是一段演示代码：
// vector的增删改查
// 尾插和尾删：push_back/pop_back
void TestVector4()
{
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
auto it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
v.pop_back();
v.pop_back();
it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
}
// 任意位置插入：insert和erase，以及查找find
// 注意find不是vector自身提供的方法，是STL提供的算法,定义在algorithm头文件中
void TestVector5()
{
// 使用列表方式初始化，C++11新语法
vector<int> v{ 1, 2, 3, 4 };
// 在指定位置前插入值为val的元素，比如：3之前插入30,如果没有则不插入
// 1. 先使用find查找3所在位置
// 注意：vector没有提供find方法，如果要查找只能使用STL提供的全局find
auto pos = find(v.begin(), v.end(), 3);
if (pos != v.end())
{
// 2. 在pos位置之前插入30
v.insert(pos, 30);
}
vector<int>::iterator it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
pos = find(v.begin(), v.end(), 3);
// 删除pos位置的数据
v.erase(pos);
it = v.begin();
while (it != v.end()) {
cout << *it << " ";
++it;
}
cout << endl;
}
// operator[]+index 和 C++11中vector的新式for+auto的遍历
// vector使用这两种遍历方式是比较便捷的。
void TestVector6()
{
vector<int> v{ 1, 2, 3, 4 };
// 通过[]读写第0个位置。
v[0] = 10;
cout << v[0] << endl;
// 1. 使用for+[]下标方式遍历
for (size_t i = 0; i < v.size(); ++i)
cout << v[i] << " ";
cout << endl;
vector<int> swapv;
swapv.swap(v);
cout << "v data:";
for (size_t i = 0; i < v.size(); ++i)
cout << v[i] << " ";
cout << endl;
// 2. 使用迭代器遍历
cout << "swapv data:";
auto it = swapv.begin();
while (it != swapv.end())
{
cout << *it << " ";
++it;
}
// 3. 使用范围for遍历
for (auto x : v)
cout << x << " ";
cout << endl;
}
运行结果：
1.2.5 vector迭代器失效问题（重点）
迭代器的主要作用是让算法能够不关心底层数据结构，实际上迭代器的底层就是一个指针，或者是对指针进行了封装，比如：vector采用连续存储空间来存储元素，所以vector的迭代器就是原生指针
T*。因此迭代器失效，实际上就是迭代器底层对应的指针所指向的空间被销毁了，该指针仍继续指向一块已经被释放的空间，若此时继续使用该迭代器，造成的后果就是程序崩溃。
对于vector来说，可能会导致其迭代器失效的操作有以下几种：
- 会引起其底层空间改变的操作，都有可能是其迭代器失效的原因，比如：resize、reserve、insert、assign、push_back等
#include - 指定位置元素的删除操作 – erase、连续的erase
#include erase删除pos位置元素之后，pos位置之后的元素会往前移动，实际上没有导致底层空间的改变（没有空间释放），理论上迭代器不应该失效，但是：若pos刚好指向最后一个元素，删除之后pos刚好是end的位置，此时end位置是没有元素的，即pos失效了。因此在vs底下，不管pos是指向哪，只要删除vector中pos指向的元素后，vs就会认为pos失效了，若不更新，则不会再给用户使用，否则直接报错；而Linux底下，该代码案例pos不指向最后一个元素，有可能不会报错！
下面是一段连续删除的代码，可以分析哪一个才是正确的：
#include - 需注意的是：Linux底下，g++编译器对迭代器失效的检测并不是很严格，处理也没有VS下极端。可以试着在这两个环境底下运行测试代码！
- 与vector类似，string在插入、扩容、erase之后，迭代器也会出现失效的情况
#include 小结：迭代器失效的解决方法就是在每次使用前，都对迭代器进行重新赋值更新即可
2. vector深度剖析及模拟实现
关于vector的内存结构，在《STL源码剖析》中有这样一幅图，清晰地表示了vector成员变量的关系。
2.1 std::vector的核心框架接口的模拟实现
vector.h
#pragma once
#include v(10, 5);
* 编译器在编译时，认为T已经被实例化为int，而10和5编译器会默认其为int类型
* 就不会走vector(size_t n, const T& value = T())这个构造方法，
* 最终选择的是：vector(InputIterator first, InputIterator last)
* 因为编译器觉得区间构造两个参数类型一致，因此编译器就会将InputIterator实例化为int
* 但是10和5根本不是一个区间，编译时就报错了
* 故需要增加该构造方法
*/
vector(int n, const T& value = T())
: _start(new T[n])
, _finish(_start + n)
, _end_of_storage(_finish)
{
for (int i = 0; i < n; ++i)
{
_start[i] = value;
}
}
// 若使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器
// 重新声明迭代器，此时迭代器区间[first,last)可以是任意容器的迭代器
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector(const vector<T>& v)
: _start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
reserve(v.capacity());
iterator it = begin();
const_iterator vit = v.cbegin();
while (vit != v.cend())
{
*it++ = *vit++;
}
_finish = it;
}
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
}
/
// 迭代器相关
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator cbegin() const
{
return _start;
}
const_iterator cend() const
{
return _finish;
}
//
// 容量相关
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _end_of_storage - _start;
}
bool empty() const
{
return _start == _finish;
}
void reserve(size_t n)
{
if (n > capacity())
{
size_t oldSize = size();
// 1. 开辟新空间
T* tmp = new T[n];
// 2. 拷贝元素
// 这里直接使用memcpy只是进行浅拷贝，对于一个若vector里面的元素是一个vector、string等，就会出现浅拷贝问题！！，此时只能使用逐个赋值去进行深拷贝！！
//if (_start)
// memcpy(tmp, _start, sizeof(T)*size);
if (_start)
{
for (size_t i = 0; i < oldSize; ++i)
tmp[i] = _start[i];//逐个赋值
// 3. 释放旧空间
delete[] _start;
}
_start = tmp;
_finish = _start + oldSize;
_end_of_storage = _start + n;
}
}
void resize(size_t n, const T& value = T())
{
// 1.如果n小于当前的size，则数据个数缩小到n
if (n <= size())
{
_finish = _start + n;
return;
}
// 2.空间不够则增容
if (n > capacity())
reserve(n);
// 3.将size扩大到n
iterator it = _finish;
_finish = _start + n;
while (it != _finish)
{
*it = value;
++it;
}
}
///
// 元素访问
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos)const
{
assert(pos < size());
return _start[pos];
}
T& front()
{
return *_start;
}
const T& front()const
{
return *_start;
}
T& back()
{
return *(_finish - 1);
}
const T& back()const
{
return *(_finish - 1);
}
/
// vector的修改操作
void push_back(const T& x)
{
//if (_finish == _end_of_storage)
//{
// reserve(capacity() == 0 ? 4 : capacity() * 2);
//}
//*_finish = x;
//++_finish;
insert(end(), x);
}
void pop_back()
{
//assert(_finish > _start);
//--_finish;
erase(end() - 1);
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_of_storage, v._end_of_storage);
}
iterator insert(iterator pos, const T& x)
{
assert(pos <= _finish);
// 空间不够先进行增容
if (_finish == _end_of_storage)
{
//size_t size = size();
size_t newCapacity = (0 == capacity()) ? 1 : capacity() * 2;
reserve(newCapacity);
// 如果发生了增容，需要重置pos
pos = _start + size();
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
return pos;
}
// 返回删除数据的下一个数据
// 可以解决:一边遍历一边删除的迭代器失效问题
iterator erase(iterator pos)
{
// 挪动数据进行删除
iterator begin = pos + 1;
while (begin != _finish) {
*(begin - 1) = *begin;
++begin;
}
--_finish;
return pos;
}
private:
iterator _start; // 指向数据块的开始
iterator _finish; // 指向有效数据的尾
iterator _end_of_storage; // 指向存储容量的尾
};
}
test.c
/// 对模拟实现的vector进行严格测试
void TestVector1()
{
lww::vector<int> v1;
lww::vector<int> v2(10, 5);
int array[] = { 1,2,3,4,5 };
lww::vector<int> v3(array, array + sizeof(array) / sizeof(array[0]));
lww::vector<int> v4(v3);
for (size_t i = 0; i < v2.size(); ++i)
{
cout << v2[i] << " ";
}
cout << endl;
auto it = v3.begin();
while (it != v3.end())
{
cout << *it << " ";
++it;
}
cout << endl;
for (auto e : v4)
{
cout << e << " ";
}
cout << endl;
}
void TestVector2()
{
lww::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
cout << v.size() << endl;
cout << v.capacity() << endl;
cout << v.front() << endl;
cout << v.back() << endl;
cout << v[0] << endl;
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
v.pop_back();
v.pop_back();
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
v.insert(v.begin(), 0);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
v.erase(v.begin() + 1);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
2.2 使用memcpy导致的浅拷贝问题
若模拟实现的vector中reserve接口中，使用的是memcpy进行的拷贝，试分析以下代码会出现的问题：
#include "vector.h"
int main()
{
lww::vector<std::string> v;
v.push_back("1111");
v.push_back("2222");
v.push_back("3333");
return 0;
}
结论：如果对象中涉及到资源管理时，不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。此时，这种情况只能用赋值！