目录
vector介绍
vector是表示可变大小数组的序列容器，是STL中的容器之一；其底层结构为可扩容的数组，所以vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。vector与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。具体结构和使用方法可查阅相关文档进行了解vector学习参考文档
vector函数接口总览
namespace djs
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
//默认成员函数
vector(); //默认构造函数
vector(size_t n, const T& val=T()); //构造函数，构造n个val
template<class InputIterator>
vector(InputIterator first, InputIterator last); //迭代器区间构造函数
vector(const vector<T>& v); //拷贝构造函数
vector<T>& operator=(const vector<T>& v); //赋值运算符重载函数
~vector(); //析构函数
//迭代器
iterator begin();
iterator end();
const_iterator begin()const;
const_iterator end()const;
//容量相关
size_t size() const;
size_t capacity() const;
bool empty() const;
void reserve(size_t n);
void resize(size_t n, const T& val = T())
//访问相关
T& operator[] (size_t n);
const T& operator[] (size_t n) const;
//修改相关
iterator insert(iterator position, const T& val);
template <class InputIterator>
void insert(iterator position, InputIterator first, InputIterator last);
void push_back (const T& val);
iterator erase (iterator position);
void pop_back();
void clear();
void swap (vector& x);
private:
iterator _start;//开始
iterator _finish;//数据个数
iterator _end_of_storage;//容量大小
};
}
还是一样，为了不与库的vector冲突，将其放在自己的命名空间里。
结构介绍
vector作为可变大小数组的序列容器，可以存各种类型的数据；在C语言模拟实现顺序表这一数据结构时，我们可以利用typedef重命名数据类型达到一键替换所要存放的数据类型的效果，但是无法做到使用同一份代码同时存储两种数据结构的效果，而C++中的模板很好解决了这个问题，模板是 STL 的基础支撑。 模板介绍。
所以vector是一个类模板，可以存储指定类型的数据。我们参考SGI版的STL中vector的源码发现，vector是用三个指针来维护存储的数据的：
成员
private：
iterator _start;//开始
iterator _finish;//数据个数
iterator _end_of_storage;//容量大小
注意：
- _finish指向的是最后一个数据的下一位，如上图所示。
实现文件介绍：
上一篇string的模拟实现中，采用了声明定义分离的方式实现；但由于vector是类模板，模板是不建议声明定义分离实现的，容易导致链接问题。SGI版的STL中声明和定义也都是放在头文件中的。
所以此次vector的模拟实现使用两个文件实现
vector.h：函数的声明和实现。
test.cpp：测试各函数。
默认成员函数
对于一些不认识的类型可以对着文档的成员类型表查看其typedef前的具体类型。
const allocator_type& alloc = allocator_type()//空间配置器，直接忽略就好。
库里实现了三个构造，一个拷贝构造函数；三个构造分别为：
- 默认构造
- 构造n个值为val的构造函数
- 迭代器区间构造
构造函数1
默认构造不写使用编译器自动生成的也行，写的话如下：将三个指针置为nullptr即可。
vector()
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{}
构造函数2
构造n个值为val的对象。
思路也很简单，在堆区开辟一段空间，然后将val存放进去。需要注意的是参数中const T& val = T()的使用，具体请到类和对象篇的匿名对象查看；使用匿名对象是因为不知道传入的值val的T具体是什么类型，所以使用内置构造将其置为0(T为int时)
vector(size_t n, const T& val = T())//类型转化int -> size_t
{
size_t endofstorage = n * 2;
_start = new T[endofstorage];
for (int i = 0; i < n; i++)
{
_start[i] = val;
}
_finish = _start + n;//更新位置
_end_of_storage = _start + endofstorage;//更新容量
}
构造函数3
迭代器区间构造：正如其名，该构造函数可以用一段区间来构造。该区间范围遵从迭代器使用的范围[左闭右开)，如：使用一个数组来构造。
int arr[] = { 1,2,3,4,5,6,7,8,9 };
vector<int>v2(arr, arr+sizeof(arr) / sizeof(int));
在类中也还是可以继续使用模板的，迭代器区间构造就是一个函数模板；实现起来也简单，先计算好构造的区间大小，再去堆区开辟对应的大小，用_finish来将元素添加进去，最后更新一下容量_end_of_storage。
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
size_t endofstorage = last - first;
_start = new T[endofstorage];
_finish = _start;//让_finish为尾，一直往后走
while (first != last)
{
*_finish = *first;
_finish++;
first++;//更新位置
}
_end_of_storage = _start + endofstorage;//更新容量
}
需要注意的是，由于构造函数2与3的存在，需要再添加一个第一个参数为int类型的构造函数；因为当我们想要用构造函数2，构造n个值为val的对象时（如下面v3）而构造函数2的参数为size_t类型，编译器会自动发生类型转化；但是有了迭代器区间后，v3的构造会更加匹配迭代器区间构造，对int解引用，导致非法的间接寻址；
解决办法就是添加一个类型更为匹配的int类型的构造函数
//由于有迭代器区间构造，构造(10,6)这种就会匹配到区间构造，造成非法寻址
vector(int n, const T& val = T())//加个整型的构造
{
size_t endofstorage = n * 2;
_start = new T[endofstorage];
for (int i = 0; i < n; i++)
{
_start[i] = val;
//push_back(val);
}
_finish = _start + n;//更新位置
_end_of_storage = _start + endofstorage;//更新容量
}
经典的深浅拷贝
拷贝构造始终都是那一套，但这里的关键点还是之前提过的深浅拷贝问题；实现拷贝构造的时候可能会贪方便，使用memcpy这个函数来实现，对于类中不涉及资源管理的使用memcpy进行拷贝那是没问题的，但是对于涉及资源管理的类再去使memcpy那就会出大麻烦，原因就是memcpy的拷贝是值拷贝，只会无脑的将内容ctrl c，ctrl v，也就是浅拷贝；而我们不写，使用编译器的拷贝构造也是浅拷贝，效果是一样的，接下来再次深入探讨深浅拷贝的问题。
使用编译器默认生成的拷贝构造就会引发以下问题，根本原因就是对同一块空间进行重复的释放，对一个非空指针调用delete[]两次（或更多次），那么程序将表现出未定义行为，这通常会导致程序崩溃或数据损坏。
- 对空指针释放是不会有问题的，但是对一个非空指针调用delete[]两次或更多就会出错。
通过监视窗口看到v2完完全全就是v1的副本
当对v1进行释放后，v2还没释放，但是v2的内容已经被释放了，因为v2是v1是副本，那么此时再对v2析构，就对造成对已释放的空间再次释放，导致程序崩溃。
浅拷贝如下图，v1，v2指向同一块内容。析构时导致崩溃。
深拷贝则为每个对象都有自己独立的一份数据。
总结：
凡是涉及了资源管理的类，其拷贝构造以及赋值重载一定要进行深拷贝。
拷贝构造
进行深拷贝，将数据一个一个喂进去。
vector(const vector<T>& v)
{
size_t endofstorage = v._end_of_storage - v._start;
_start = new T[endofstorage];
int i;//写外面
for (i=0; v._start + i < v._finish; i++)
{
_start[i] = v._start[i];//运用了赋值重载
}
_finish = _start + i;
_end_of_storage = _start + endofstorage;
}
也有更简洁的写法，使用等会要实现的reserve开好空间，再利用范围for将数据尾插进去。
//现代写法
vector(const vector<T>& v)
{
reserve(v.capacity()); //调用reserve函数将容器容量设置为与v相同
for (auto e : v) //将容器v当中的数据一个个尾插过来
{
push_back(e);
}
}
赋值重载
拷贝构造将数据一个一个插进去时就用到了赋值重载，所以赋值重载也需要进行深拷贝；开后空间将数据插入后别忘记对原有空间进行释放，最后再把_start,_finish,_end_of_storage更新。
vector<T>& operator=(const vector<T>& v)
{
//赋值重载是对已存在对象而言，记得确保数据拷贝完成再释放原有空间
if (this != &v)//避免给自己赋值
{
size_t endofstorage = v._end_of_storage - v._start;
T* tmp = new T[endofstorage];//临时数组接收
int i;
for (i = 0; v._start+i < v._finish; i++)
{
tmp[i] = v._start[i];
}
if (_start)//判断一下
{
delete[] _start;//释放空指针不会出错，但还是要注意规范。
}
_start = tmp;
_finish = _start + i;
_end_of_storage = _start + endofstorage;
return *this;
}
}
析构函数
释放掉由_start指向的空间即可。
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
}
迭代器
SGI版下的vector的迭代器还是原生指针，所以将模板类型T* typedef为iterator及const版。
- 注意：VS(PJ版)下vector的迭代器不是原生指针
public:
typedef T* iterator;
typedef const T* const_iterator;
begin和end
vector当中的begin函数返回容器的首地址，end函数返回容器当中有效数据的下一个数据的地址。
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
还需要重载一对适用于const对象的begin和end函数，使得const对象调用begin和end函数时所得到的迭代器只能对数据进行读操作，而不能进行修改。
const_iterator begin()const
{
return _start;
}
const_iterator end()const
{
return _finish;
}
有了迭代器，范围for也就支持了。
int arr[] = { 1,2,3,4,5,6,7,8,9 };
vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));
for (auto e : v1)
{
cout << e;
}
cout << endl;
容量相关函数
size
获取数据个数：指针_finish 和_start相减便是数据个数
size_t size() const
{
return _finish - _start;
}
capacity
获取容量：指针_end_of_storage ， _start相减为容量。
size_t capacity() const
{
return _end_of_storage - _start;
}
empty
判断是否为空：检查_start与_finish是否相等。
bool empty() const
{
return _start == _finish;
}
reserve
功能：
- 当n大于对象当前的capacity时，将capacity扩大到n或大于n。
- 当n小于对象当前的capacity时，不做响应。
这里需要注意的是我们是用三个指针来维护数据的，一旦开辟了新的空间并把原有数据拷贝过去后，三个指针那就都失效了，必须更新指针的位置；扩容前需要记录_finish与_start的间距，有了这间距等会才能恢复_finish的位置。
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = size();//先记录数据与起始位置的间隔
T* tmp = new T[n];
if (_start)//需要检查，空则不需要拷贝原有数据
{
for (size_t i = 0; i < sz; ++i)
{
tmp[i] = _start[i];
}
delete[] _start;
}
//更新位置
_start = tmp;
_finish = _start + sz;//恢复位置
_end_of_storage = _start + n;
}
}
resize
功能：
- 当n大于当前的size时，将size扩大到n，扩大的数据为val，若val未给出，则默认为容器所存储类型的默认构造函数所构造出来的值。
- 当n小于当前的size时，将size缩小到n。
首先检查是否需要扩容，之后利用一个循环比较n与sz的关系，若n大于sz则插入数据，否则不做处理。最后重新定位一下_finish的位置。
void resize(size_t n, const T& val = T())//库的不是引用，而是传值
{
if (n > capacity())
{
reserve(n);
}
size_t sz = size();//当前个数
while (n > sz)//小了不处理，大了加
{
*_finish = val;
_finish++;
sz++;//进入循环说明n>sz,结束条件则为n==sz
}
//重新定位(也处理小的情况)
_finish = _start + n;
}
访问
operator[]
vector的底层还是数组，支持下标访问：_start维护的是整段数据，支持下标访问，所以直接返回对应的数据即可；下标访问是可以修改内容的，采用引用返回。
T& operator[] (size_t n)//下标
{
return _start[n];
}
重载运算符[ ]时需要重载一个适用于const容器的，因为const容器通过“下标+[ ]”获取到的数据只允许进行读操作，不能对数据进行修改。
const T& operator[] (size_t n) const
{
return _start[n];
}
修改相关函数
insert
库里有三个insert的重载，我们实现第一，三个
一：
insert函数可以在所给迭代器position位置插入数据，在插入数据前先判断是否需要增容，然后将position位置及其之后的数据统一向后挪动一位，以留出position位置进行插入，最后将数据插入到position位置并返回position的位置。
- 需要注意的是position是迭代器类型，一旦进行扩容，就需要重新定位position在新区间的位置，所以在扩容前记录position与_start的间距。
- 其返回值为返回插入位置的迭代器，也就是position。
iterator insert(iterator position, const T& val)
{
assert(position >= _start);
assert(position <= _finish);
if (_finish + 1 > _end_of_storage)//检查是否需要扩容
{
size_t gap = position - _start;
reserve(capacity()==0?4:capacity() * 2);//防止capacity为0的情况
position = _start + gap;
}
iterator end = _finish;//T*end
while (end > position)//end==pos时不需要移
{
*end = *(end - 1);
end--;
}
*end = val;//插入
_finish++;
return position;
}
二：
插入一段迭代器区间:用一个循环其中调用第一个insert将数据添加进去。
- 使用insert后注意迭代器失效问题，这里用重新接受其返回值解决。
template <class InputIterator>
void insert(iterator position, InputIterator first, InputIterator last)
{
assert(position >= _start);
assert(position <= _finish);
while (first != last)
{
position = insert(position, *first);//注意迭代器失效问题
position++;
first++;
}
}
push_back
尾插一个元素：调用insert完成。
void push_back(const T& val)
{
insert(_finish, val);
}
erase
删除传入迭代器位置的元素：从position位置开始从后往前覆盖。返回值为：返回删除元素后一位，但已覆盖，实际还是position
iterator erase(iterator position)
{
assert(position >= _start);
assert(position <= _finish);
assert(!empty());
iterator end = position;
while (end<_finish)
{
*end = *(end + 1);
end++;
}
_finish--;
return position;//返回删除元素后一位，但已覆盖，实际还是position
}
pop_back
尾删：调用erase。
void pop_back()
{
erase(_finish - 1);
}
clear
清空数据但容量不改：让_finish=_start即可。
void clear()
{
_finish = _start;//只是禁止了迭代器访问的方式，数据还在
}
swap
交换两个vector：由于swap的重载非常多，可以使用交换单一变量的swap，逐个指针交换。也可以直接使用交换vector的swap（非成员函数）。
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_of_storage, v._end_of_storage);
//std::swap(*this,v);
}
迭代器失效问题
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了
封装（PJJ版），比如：vector的迭代器（SGI版）就是原生态指针T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。
对于vector可能会导致其迭代器失效的操作有：
问题一：会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、
push_back等。
如：使用reserve
SGI版的vector的reserve虽然没有报错，但是可以看到其行为是未定义或者说越界访问了。
而PJ版(VS)的vector的reserve则是崩溃了。
出错原因：使用reserve有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的空间，而引起代码运行时崩溃。
解决办法也简单：使用前重新赋值获取迭代器位置。
问题二：指定位置元素的删除操作——erase
程序没有崩溃，但是可以看到此时的it2已经不是指向1了，所以其结果也还是错的。
VS的直接崩溃
erase删除it2位置元素后，it2位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果it2刚好是最后一个元素，删完之后it2刚好是end的位置，而end位置是没有元素的，那么it2就失效了。因此删除vector中任意位置上元素时，VS就认为该位置迭代器失效了，不能再使用了。
同样的，该问题也能通过重新赋值解决。
再如以下代码：
删除容器中所有的偶数。
int arr[] = { 1,2,3,4,5,6 };
std::vector<int>v2(arr, arr+sizeof(arr)/sizeof(int));
auto it2 = v2.begin();
v2.erase(it2);
while (it2 != v2.end())
{
if (*it2 % 2 == 0)
{
v2.erase(it2);
}
else
{
++it2;
}
}
此时可以看到VS处理得很极端，直接崩溃了。
而解决办法是接受其返回值，重新获取迭代器位置。
总结：
迭代器失效解决方法：使用迭代器时，永远记住一句话：每次使用前，对迭代器进行重新赋值。
PJ版的与SGI版的迭代器由于实现不同，导致他们的处理方式也不一样。
- Linux下(SGI版)，g++编译器对迭代器失效的检测并不是非常严格，处理也没有VS(PJ版)下极端。
- SGI版的STL中，迭代器失效后，代码并不一定会崩溃，但是运行结果肯定不对，如果it不在begin和end范围内，肯定会崩溃的。
string也会有以上问题，但是我们一般不使用迭代器访问。
484
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
