本课涉及的所有代码见以下链接，欢迎参考指正！
vector · 王哲/practice - 码云 - 开源中国 (gitee.com)
vector介绍【简单了解即可】
1. vector 是表示可变大小数组的序列容器，和string非常相似，string类似于字符数组，而vector则类似于存储其它类型数据的数组。2. 就像数组一样， vector 也采用的连续存储空间来存储元素。也就是意味着可以采用下标对 vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。3. 本质讲， vector 使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小，为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因此每当一个新的元素加入到容器的时候，vector 并不会每次都重新分配大小。4. vector 分配空间策略： vector 会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。5. 因此， vector 占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。6. 与其它动态序列容器相比（ deque, list and forward_list ）， vector 在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list 和 forward_list统一的迭代器和引用更好。
vector的使用
需查看文档了解常用接口，熟练掌握各个常用接口用法，下面分别介绍并测试。
1.构造函数
| 构造函数 | 接口说明 |
|
vector()
（重点）
| 无参构造 |
|
vector
（
size_type n, const value_type& val = value_type()
）
| 构造并初始化为n个val |
|
vector (const vector& x);
（重点）
| 拷贝构造 |
|
vector (InputIterator first, InputIterator last);
| 使用迭代器进行初始化构造 |
无参构造+vector的三种遍历方式
vector<int> v1;//无参构造
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
//vector访问方式
//方式一：[]+下标 访问
for (int i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
//方式二：迭代器 访问
auto it = v1.begin();
while (it != v1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
//方式三：范围for 访问
for (auto ch : v1)
{
cout << ch << " ";
}
cout << endl;
//不仅能通过以上三种方式访问vector，还可以修改测试结果如下：
其它构造方式
vector<int> v1;//无参构造
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
for (int i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
vector<int> v2(10, 4);//构造并初始化为10个4
v2.push_back(11);
v2.push_back(12);
v2.push_back(13);
v2.push_back(14);
v2.push_back(15);
for (int i = 0; i < v2.size(); i++)
{
cout << v2[i] << " ";
}
cout << endl;
vector<int>v3(v1);//拷贝构造
for (int i = 0; i < v3.size(); i++)
{
cout << v3[i] << " ";
}
cout << endl;
vector<int>v4(v2.begin(), v2.end());//迭代器构造
for (int i = 0; i < v4.size(); i++)
{
cout << v4[i] << " ";
}
cout << endl;测试结果：
我们发现在用迭代器构造时的参数是InputIterator first和InputIterator last，并没有直接使用vector对应的begin（）和end（），这是设计者为了使其在用迭代器构造时不仅能用vector的迭代器构造，还能用其它容器的迭代器构造 。
测试结果：
2.迭代器
| iterator的使用 | 接口说明 |
| begin()+end() |
获取第一个数据位置的
iterator/const_iterator
， 获取最后一个数据的下一个位置
的
iterator/const_iterator
|
| rbegin()+rend() |
获取最后一个数据位置的
reverse_iterator
，获取第一个数据前一个位置的
reverse_iterator
|
我们可以利用正向迭代器和反向迭代器对vector中的数据进行修改和遍历打印！ 
void vector_test2()
{
vector<int> v2(10, 4);//构造并初始化为10个4
v2.push_back(11);
v2.push_back(12);
v2.push_back(13);
v2.push_back(14);
v2.push_back(15);
for (int i = 0; i < v2.size(); i++)
{
cout << v2[i] << " ";
}
cout << endl;
vector<int>v4(v2.begin(), v2.end());//用正向迭代器构造
vector<int>::iterator it = v4.begin();
while(it!=v4.end())//用正向迭代器修改并遍历打印
{
*it *= 2;
cout << *it << ' ';
it++;
}
cout << endl;
vector<int>::reverse_iterator rit = v2.rbegin();
while (rit != v2.rend())//用反向迭代器遍历打印
{
cout << *rit << ' ';
rit++;
}
cout << endl;
}测试结果：
3.容量操作
| 容量相关函数 | 接口说明 |
| size | 获取数据个数 |
| capacity | 获取容量大小 |
| empty | 判断是否为空 |
| reserve | 改变vector的capacity，开空间但不初始化 |
| resize | 改变vector的size，开空间+初始化 |
- capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL。
vs下运行结果：
g++下运行结果：
- reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。resize在开空间的同时还会进行初始化，影响size。
#include<time.h> void TestVectorExpand() { size_t sz; vector<int> v; const size_t n = 100000000; //v.reserve(n); sz = v.capacity(); size_t begin = clock(); //cout << "making v grow:\n"; for (int i = 0; i < n; ++i) { v.push_back(i); } size_t end = clock(); cout << "时间:" << end - begin << endl; }
void vector_test3()
{
vector<int> v1;//无参构造
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
for (int i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
cout << v1.size() << endl;
cout << v1.capacity() << endl;
v1.reserve(21);
for (int i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
cout << v1.size() << endl;
cout << v1.capacity() << endl;
v1.resize(25, 4);
for (int i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
cout << v1.size() << endl;
cout << v1.capacity() << endl;
}测试结果：
4.vector 增删查改
| vector增删查改 | 接口说明 |
| push_back(重点) | 尾插 |
| pop_back(重点) | 尾删 |
| find |
查找（注意这个是算法模块实现，不是
vector
的成员接口）
|
| insert |
在
position
之前插入
val
|
| erase |
删除
position
位置的数据
|
| swap |
交换两个
vector
的数据空间
|
| operator[](重点) |
像数组一样访问
|
尾插、尾删：
任意位置的插入、删除：
这里插入删除就要和string类做区分，在string类由于经常会对某一位置的字符串或字符进行操作，因此不仅提供了find（）接口，设计insert（）和erase（）时，使他们能够直接通过下标确定位置，而vector类中，无论是插入还是删除只针对单个元素，也没有很多用到find（）的场景，故并未提供此接口，我们需要通过算法模块的find()，来找到想插入或删除元素的位置，将相应迭代器位置传给insert（）和erase（），才能实现各个位置的插入删除。
- find()适用于所有容器的迭代器
成功在pos位置插入元素：
继续删除pos位置，会报错：
上图报错主要是因为迭代器失效，什么是迭代器失效？在模拟实现vector时总结将具体原因。
vector的模拟实现
在模拟实现之前，我们最好先去看一下STL某一版本的源码，知道其大体包括的成员变量以及实现方式，在此基础上进行模拟实现，更具学习价值，我参考的是SGI版本下的源码。【Tips1:大家在看源码时，不必追求逐行看懂，要抓住重点，因为源码中考虑到实际的应用，会有许多我们现阶段无法理解的内容，实际上的精华并不在此，我们只需看懂主要内容，就能满足现阶段的学习需求】
SGI版本下vector.h主要内容提取：
了解基本结构后我们就可以自己实现一个vector。
基本成员变量的声明及构造函数和析构函数：
//自己实现一个vector，需要一个属于自己的命名空间
namespace wz
{
template<class T>
class vector
{
typedef T* iterator;//即此处迭代器为原生指针
public:
//无参构造函数
vector()
:_start(nullptr)
, _finish(nullptr)
, end_of_storage(nullptr)
{}
//析构函数
~vector()
{
delete [] _start;
_start = _finish = end_of_storage = nullptr;
}
private:
iterator _start;
iterator _finish;
iterator end_of_storage;
};
}构造函数测试结果如下：
容量相关函数：
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
size_t size()
{
return _finish - _start;
}
size_t capacity()
{
return end_of_storage - _start;
}
void reserve(size_t n)//只扩容，不缩容，改变容量，不改变数据个数
{
if (n > capacity())//只扩容
{
size_t sz = size();
//重新找一块空间
T* tmp=new T[n];
//原来的vector不为空才需要拷贝数据，否则不需要
if (_start)
{
memcpy(tmp, _start, sizeof(T) * size());
}
//释放原空间
delete[] _start;
_start = tmp;
_finish = _start + sz;//为什么不用_start+size()
//因为size()是_finish-_start返回的，上一步_start已经改变，_finish并未改变
//此时size()的结果不正确，因此，在开头就用sz来记录size()
end_of_storage = _start + n;
}
}
void resize(size_t n, const T& val)//只能扩容，不能缩容，改变数据个数，容量不够时，也改变容量
{
//当n<size()时，此时改变size()相当于删除数据
if (n < size())
{
_finish = _start + n;
}
//当n>size()时，将未初始化的数据初始化为val
else
{
//容量不够，用reserve（）扩容
if (n > capacity())
{
reserve(n); }
//将未初始化的数据全部初始化为val
while(_finish!=_start+n)
{
*_finish = val;
_finish++;
}
}
}
void push_back(const T& val)
{
if (_finish==end_of_storage)//容量满时需扩容
{
reserve(capacity() == 0 ? 4 : capacity() * 2);//首次扩容需单独考虑
}
*_finish = val;
_finish++;
}
void pop_back()
{
//删除需考虑是否为空
if (!empty())
{
_finish--;
}
}
bool empty()
{
return _start == _finish;
}测试结果如下：
任意位置的插入、删除：
//任意位置的插入删除
void insert(iterator pos, const T& val)
{
assert(pos >= _start && pos <= _finish);
//判断是否需要扩容
if (_finish == end_of_storage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
end--;
}
*pos = val;
_finish++;
}
void erase(iterator pos)
{
assert(pos>=_start&&pos<_finish);
iterator begin=pos;
while (begin < _finish)
{
*begin = *(begin + 1);
begin++;
}
_finish--;
}上面的代码有问题吗？
迭代器失效问题：
1.若插入数据时发生了扩容，那么_start,_finish,_end_of_storage都会被刷新，但找到的pos不会更新，此时如果再对pos处进行插入，由于pos和_start和_finish的相对位置发生改变，要么会死循环，要么压根不进入循环，无论那种情况，都会出现问题，因此我们需要在扩容后利用pos与_start相对距离不变的特性更新pos，后面才能进行正常的数据移动和插入。
2.上面虽然我们在insert内部对pos进行了更新，但由于传值传参，原来的pos仍未改变，此时若想要继续对pos位置的数据进行操作，仍然会出现问题，为了解决这一问题，我们在设计insert函数时给它提供一个返回值，将更新后的pos作为返回值，这样在想要继续对pos位置进行操作时，只需用一个值来接收一下返回值，就可正常使用了。
因此正确的insert如下：
//任意位置的插入删除 iterator insert(iterator pos, const T& val) { assert(pos >= _start && pos <= _finish); //判断是否需要扩容 if (_finish == end_of_storage) { //此处若扩容，则_start和_finish都会更新，而pos不会，因此要手动更新pos size_t len = pos - _start; reserve(capacity() == 0 ? 4 : capacity() * 2); pos = _start + len;//相对距离不变 } iterator end = _finish - 1; while (end >= pos) { *(end + 1) = *end; end--; } *pos = val; _finish++; return pos; }测试代码和结果如下：
void my_vector_test4() { wz::vector<int> v1; v1.push_back(1); v1.push_back(2); v1.push_back(3); v1.push_back(4); for (auto ch : v1) { cout << ch << " "; } cout << endl; cout << v1.size() << " " << v1.capacity() << " " << endl; wz::vector<int>::iterator pos1 = find(v1.begin(), v1.end(), 3); pos1=v1.insert(pos1, 19); for (auto ch : v1) { cout << ch << " "; } cout << endl; pos1=v1.insert(pos1, 17);//继续在pos1处之前插入数据 for (auto ch : v1) { cout << ch << " "; } cout << endl; (*pos1)++;//修改pos1处值 for (auto ch : v1) { cout << ch << " "; } cout << endl; v1.erase(pos1);//删除pos1处的值 for (auto ch : v1) { cout << ch << " "; } cout << endl; }
3.以上在设计insert时涉及到扩容操作，这是由于空间位置的改变而造成的迭代器失效的问题，那么在设计erase时，没有扩容问题，这时需不需要考虑迭代器失效的问题呢？
我们来看下面一段代码：
void my_vector_test5() { vector<int> v1; v1.push_back(1); v1.push_back(2); v1.push_back(3); v1.push_back(4); v1.push_back(5); for (auto e : v1) { cout << e << " "; } cout << endl; auto pos = find(v1.begin(), v1.end(), 5); if (pos != v1.end()) { v1.erase(pos); } (*pos)++; for (auto e : v1) { cout << e << " "; } cout << endl; }经过验证我们发现这段代码在VS版本下会报错，而在SGI版本下则可以正常运行，实际上这是因为：我们实现的vector是参考的SGI版本的源码，即用原生指针来实现了迭代器，因此可以在g++编译下正常运行，而VS实现迭代器更为复杂，检查也更为严格，它认为erase后的迭代器是失效的，此时我们实现的代码运行就可能会出现运行失败的问题【注意：运行成功不代表得出的结果是正确的】，哪一种版本的检查更合理一些呢？我们对以上代码的运行结果进行分析：
通过分析，我们知道实际上VS的判断更为合理，此时pos指向的实际上是_finish指向的位置，这个位置是不应该被访问的 ，为了避免出现这样的问题，VS就会认为，只要erase后，迭代器就要失效，如果我们确实想要用这个位置，就要在设计erase时也给它设置一个返回值，一般我们返回这个数据的下一个数据的位置，由于挪动，因此还是返回pos。
即正确的erase如下：
iterator erase(iterator pos) { assert(pos>=_start&&pos<_finish); iterator begin=pos; while (begin < _finish) { *begin = *(begin + 1); begin++; } _finish--; return pos; }测试代码及运行结果如下：
void my_vector_test5() { wz::vector<int> v1; v1.push_back(1); v1.push_back(2); v1.push_back(3); v1.push_back(4); v1.push_back(5); for (auto e : v1) { cout << e << " "; } cout << endl; auto pos = find(v1.begin(), v1.end(), 4); if (pos != v1.end()) { auto it=v1.erase(pos); (*it)++; } }
综上，我们就讲清楚了vector的迭代器失效的问题，一定要多看几遍，加深理解，尤其是对于erase的迭代器失效问题。
小练习：我们想利用erase来删除一个vector对象中存储的所有偶数
代码：
//要综合考虑连续偶数、偶数在头、偶数在尾的情况 void my_vector_test6() { wz::vector<int> v1; v1.push_back(10); v1.push_back(2); v1.push_back(3); v1.push_back(4); v1.push_back(5); v1.push_back(50); wz::vector<int>::iterator it = v1.begin(); while (it != v1.end()) { if (*it % 2 == 0)//若为偶数则删除，it不变 { it = v1.erase(it); } else//若不是偶数，it++继续判断 { ++it; } } for (auto e : v1) { cout << e << " "; } cout << endl; }测试结果：
总结：其实对于vector来说，实际情况中我们很少用insert和erase，因为涉及到反复的挪动数据，会使性能变低。
补充：其它构造函数
//用n个val值构造
vector(size_t n, const T& val = T())//这里T（）表示调用T类型的默认构造
: _start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
reserve(n);
for (size_t i = 0; i < n; ++i)
{
push_back(val);
}
}
//迭代器构造
// [first, last)
template <class InputIterator>
vector(InputIterator first, InputIterator last)
: _start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
while (first != last)
{
push_back(*first);
++first;
}
}注释：
1.对于用n个val构造的构造函数，val的缺省值实际上是调用了相应类型匿名对象的默认构造，对于自定义类型，不做过多解释，那对于内置类型来说，难道也有相应的默认构造吗？这里为了模板的正常使用，我们认为内置类型也有其默认构造，而在平常使用时，我们一般不这么认为，不同编译器有不同的编译结果，只需明白，这里是为了模板的使用而有的特殊情况。
2.我们之前还说过，匿名对象的生命周期只有一行，那为什么这里可以用？我们要明白，匿名对象的生命周期之所以只有一行，是因为它没有名字，后面没人用它，而这里相当于给匿名对象起了别名，val就是它的名字，使用val自然也就是使用这个匿名对象，那么匿名对象的生命周期也会随着val生命周期的结束而结束，即const引用可以延长匿名对象的生命周期，注意：匿名对象具有常性，因此只能用const引用。
void my_vector_test11()
{
int a[] = { 1,2,3,4,5,6,7,8,9,10 };
wz::vector<int> v2(a,a+10);
for (auto e : v2)
{
cout << e << " ";
}
cout << endl;
wz::vector<int> v3(6, 9);
for (auto e : v3)
{
cout << e << " ";
}
cout << endl;
}测试上列代码时，会出现“非法间接寻址”这样的错误提示，为什么呢？这是当以上提到的两个构造函数同时出现的时候，会去匹配最相近的构造函数，编译器会将整数默认为整型，因此它会将迭代器构造函数的两个参数实例化两个整型，构造函数内部，有解引用操作，相当于对整型解引用，自然会报错，有两种解决方式，第一，传参时参数1后加u，表示其为无符号整型，第二种就是重载一个两参数都为整型的版本。
如下：
//用n个val值构造 vector(size_t n, const T& val = T())//这里T（）表示调用T类型的默认构造 : _start(nullptr) , _finish(nullptr) , _end_of_storage(nullptr) { reserve(n); for (size_t i = 0; i < n; ++i) { push_back(val); } } //重载两整型参数版本 vector(int n, const T& val = T())//这里T（）表示调用T类型的默认构造 : _start(nullptr) , _finish(nullptr) , _end_of_storage(nullptr) { reserve(n); for (int i = 0; i < n; ++i) { push_back(val); } } //迭代器构造 // [first, last) template <class InputIterator> vector(InputIterator first, InputIterator last) : _start(nullptr) , _finish(nullptr) , _end_of_storage(nullptr) { while (first != last) { push_back(*first); ++first; } } //测试函数 void my_vector_test11() { int a[] = { 1,2,3,4,5,6,7,8,9,10 }; wz::vector<int> v2(a,a+10); for (auto e : v2) { cout << e << " "; } cout << endl; wz::vector<int> v3(6u, 9);//第一个参数后+u for (auto e : v3) { cout << e << " "; } cout << endl; }
注意:对于构造函数，如果不想每个都写初始化列表，就要在声明的时候给参数，如下：
//无参构造函数
vector()
{}
//用n个val值构造
vector(size_t n, const T& val = T())//这里T（）表示调用T类型的默认构造
{
reserve(n);
for (size_t i = 0; i < n; ++i)
{
push_back(val);
}
}
//迭代器构造，甚至可以用数组区间来构建
// [first, last)
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
private:
iterator _start=nullptr;
iterator _finish=nulptr;
iterator end_of_storage=nullptr;拷贝构造
//按照一般的理解直接来写我们会写成如下形式
//拷贝构造
vector(vector<T>& v)
: _start(nullptr)
, _finish(nullptr)
, end_of_storage(nullptr)
{
reserve(v.capacity());//直接复用reserve开空间,这里会处理end_of_storage
memcpy(_start, v._start, sizeof(T) * v.size());
_finish = _start + v.size();
}对于内置类型，如int来说，我们可以发现没有什么问题，测试结果如下:
但如果vector里存的是自定义类型，如string对象或vector<int>对象，就会出现问题，若存的是string对象，图解如下：
由上可知，memcpy本身也属于浅拷贝，要想正常拷贝自定义类型，要改为深拷贝，如下：
//拷贝构造 vector(vector<T>& v)//不要忘记初始化列表！！！ : _start(nullptr) , _finish(nullptr) , end_of_storage(nullptr) { reserve(v.capacity());//直接复用reserve开空间,这里会处理end_of_storage for (int i = 0; i < v.size();i++) { _start[i] = v._start[i]; } _finish = _start + v.size(); end_of_storage = _start + v.capacity(); }但是改过之后，发现仍然会报错，为什么呢？因为我们复用了reverse，而reverse的实现中扩容时也用了memcpy，这也属于浅拷贝，因此reverse中也要改为深拷贝，如下：
void reserve(size_t n)//只扩容，不缩容，改变容量，不改变数据个数 { if (n > capacity())//只扩容 { size_t sz = size(); //重新找一块空间 T* tmp=new T[n]; //原来的vector不为空才需要拷贝数据，否则不需要 if (_start) { for (int i = 0; i < sz; i++) { tmp[i] = _start[i]; } } //释放原空间 delete[] _start; _start = tmp; _finish = _start + sz;//为什么不用_start+size() //因为size()是_finish-_start返回的，上一步_start已经改变，_finish并未改变 //此时size()的结果不正确，因此，在开头就用sz来记录size() end_of_storage = _start + n; } }
若存的是vector<int>,图解如下：
由上可知，我们还需要实现vector的赋值重载，否则还会有浅拷贝的问题，如下：
void swap(vector<T> v) { std::swap(_start, v._start); std::swap(_finish, v._finish); std::swap(end_of_storage, v.end_of_storage); } //赋值重载 vector<T>& operator =(vector<T> v) { //直接用现代写法：即借助一个新的对象来实现，互相交换 //出作用域后，该临时对象会销毁，不会影响其它对象的值 vector<T> tmp(v.begin(), v.end()); swap(tmp);//在vector类中利用std中的swap实现一下 return *this; }测试结果如下：
[ ]重载
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}以上就是vector需掌握的大部分内容，想要熟练应用，还须多加练习。
练习：
1.杨辉三角
2.电话号码的字母组合
本课涉及的所有代码见以下链接，欢迎参考指正！
扫一扫
1557
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
