一、标准库中的vector
1.vector文档介绍
（1）vector是表示可变大小数组的序列容器。
（2）像数组一样，vector也采用连续存储空间来存储元素，也就意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是也有区别，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
（3）本质讲，vector使用动态分配数组来存储它的元素，当新元素插入的时候，这个数组需要被重新分配大小为了增加存储空间。其方法是，分配一个新的数组，然后将全部元素移到这个数组内。就时间而言，这是一个相对代价较高的任务，因为每当一个新的元素插入到容器的时候，vector并不会每次都重新分配大小。
（4）vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成。
（5）因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
（6）与其他动态序列容器相比，vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效，对于其他不在末尾的删除和插入操作，效率更低。
2.vector的使用
2.1 vector的定义
2.2 vector iterator的使用
2.3 vector空间增长问题
（1）capacity的代码在vs和g++下的实现是不同的，vs下是PJ版的STL，capacity是按照1.5倍增长，而g++是SGI版的STL，是按照2倍增长。
（2）reserve只负责开辟空间，如果确定知道需要使用多少空间，reserve可以缓解vector扩容的代价缺陷问题。reserve期望开辟的空间大小只有比原空间大的情况下，才会真的去开辟空间进行扩容。
（3）resize在开辟空间的同时，还会进行初始化，影响size大小。
2.4vector的增删查改
3.vector迭代器失效问题★
3.1 什么是迭代器失效
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是指针，或者是对指针进行了封装。
因此迭代器失效，实际就是迭代器底层对应指针失效，即所指向的空间非法（越界，或空间已经被释放）。
后果就是，若继续使用已经失效的迭代器，程序就很可能会崩溃。
3.2 可能导致迭代器失效的操作
（1）会引起底层空间改变的操作，都有可能会引起迭代器失效
如：resize、reserve、insert、push_back等。
（2）指定位置的删除操作--erase
erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上迭代器不会失效，但是如果pos刚好是最后一个元素，删除之后pos刚好就是end的位置，而end位置是没有元素的，那么pos位置的迭代器就失效了。
3.2 如何避免
在使用前，对迭代器重新赋值即可。
二、模拟实现vector
1.实现接口
1.1默认成员函数
vector();
vector(int n, const T& val = T());
template<class Iterator>
vector(Iterator start, Iterator end);
vector(const vector<T>& v);
vector<T>& operator=(vector<T> v);
~vector();
1.2迭代器相关
typedef T* iterator;
iterator begin();
iterator end();
iterator rbegin();
iterator rend();1.3容量相关
size_t size() const ;
size_t capacity() const ;
bool empty() const;
void resize(size_t new_size, const T& val = T()) ;
void reserve(size_t new_capacity) ;1.4元素访问相关
T& front() ;
const T& front() const;
T& back();
const T& back() const ;
T& operator[](size_t index);
const T& operator[](size_t index) const ;1.5元素修改相关
void push_back(const T& val) ;
void pop_back() ;
iterator insert(iterator pos, const T& val) ;
iterator erase(iterator pos) ;
void clear() ;
void swap(vector<T>& v);1.6私有成员
iterator _start;//指向数据块的初始位置
iterator _end;//指向有效数据的末尾
iterator _endofcapacity;//指向存储容量的末尾2.代码实现
#include <iostream>
#include <assert.h>
#include <string>
//#include <vector>
using namespace std;
namespace MyVector {
template<class T>
class vector {
public:
//vector的迭代器是原生态的指针
typedef T* iterator;
typedef const T* const_iterator;
/*----------类的默认成员函数----------*/
//构造函数
vector()
:_start(nullptr)
,_end(nullptr)
,_endofcapacity(nullptr)
{}
vector(int n, const T& val = T())
:_start(new T[n])
,_end(_start + n)
,_endofcapacity(_start + n)
{
for (int i = 0; i < n; ++i) {
_start[i] = val;
}
}
template<class Iterator>
vector(Iterator start, Iterator end) {
//注意，求区间长度不能直接用end-start
//因为有可能不是连续空间，比如list
//获取区间长度
size_t size = 0;
Iterator it = start;
while (it != end) {
++it;
++size;
}
//开辟空间，拷贝元素
_start = new T[size];
_end = _start;
while (start != end) {
*_end = *start;
++_end;
++start;
}
_endofcapacity = _end;
}
//拷贝构造
vector(const vector<T>& v)
:_start(new T[v.size()])
{
size_t size = v.size();
for (size_t i = 0; i < size; ++i) {
_start[i] = v[i];
}
_end = _start + size;
_endofcapacity = _end;
}
//赋值运算符重载
vector<T>& operator=(vector<T> v) {
swap(v);
return *this;
}
//析构函数
~vector() {
if (_start) {
delete[] _start;
_start = nullptr;
_end = nullptr;
_endofcapacity = nullptr;
}
}
/*----------迭代器----------*/
iterator begin() {
return _start;
}
iterator end() {
return _end;
}
iterator rbegin() {
return _end;
}
iterator rend() {
return _start;
}
/*----------容量相关----------*/
size_t size() const {
return _end - _start;
}
size_t capacity() const {
return _endofcapacity - _start;
}
bool empty() const {
return _start == _end;
}
void resize(size_t new_size, const T& val = T()) {
size_t old_size = size();
if (new_size <= old_size) {
_end = _start + new_size;
}
else {
size_t old_capacity = capacity();
if (new_size > old_capacity) {//需要扩容
reserve(new_size);
}
//为多出的空间放置val
while (_end != _endofcapacity) {
*_end = val;
++_end;
}
}
}
void reserve(size_t new_capacity) {//扩容
size_t old_capacity = capacity();
size_t size = this->size();
if (new_capacity > old_capacity) {
//申请空间
T* temp = new T[new_capacity];
if (temp) {
//拷贝元素
//memcpy(temp, _start, sizeof(T) * size);//浅拷贝
for (size_t i = 0; i < this->size(); ++i) {
temp[i] = _start[i];
}
//释放原空间
delete[] _start;
_start = temp;
_end = _start + size;
_endofcapacity = _start + new_capacity;
}
}
}
/*----------元素访问----------*/
T& front() {
return *_start;
}
const T& front() const {
return *_start;
}
T& back() {
return *(_end - 1);
}
const T& back() const {
return *(_end - 1);
}
T& operator[](size_t index) {
assert(index < size());
return _start[index];
}
const T& operator[](size_t index) const {
assert(index < size());
return _start[index];
}
/*----------元素修改----------*/
void push_back(const T& val) {
if (_end == _endofcapacity) {//需要扩容
size_t size = this->size();
if (size == 0) size = 1;//防止对0两倍扩容还是0
reserve(size * 2);
}
*_end = val;
++_end;
}
void pop_back() {
if (empty()) return;
--_end;
}
iterator insert(iterator pos, const T& val) {
if (pos < _start || pos > _end) assert(0);
if (_end == _endofcapacity) {//需要扩容
size_t len = pos - _start;//记录pos距离开头的长度
size_t size = this->size();
if (size == 0) size = 1;//防止对0两倍扩容还是0
reserve(size * 2);
pos = _start + len;//发生扩容后，pos迭代器失效，需要重新赋值pos
}
//搬移元素
iterator it = _end;
while (it != pos) {
*it = *(it - 1);
--it;
}
//放置插入元素
*it = val;
_end++;
return pos;
}
iterator erase(iterator pos) {//删除
if (pos < _start || pos >= _end) assert(0);
iterator it = pos;
while (it != _end - 1) {
*it = *(it + 1);
++it;
}
_end--;
return pos;
}
void clear() {
_end = _start;
}
void swap(vector<T>& v) {
std::swap(_start, v._start);
std::swap(_end, v._end);
std::swap(_endofcapacity, v._endofcapacity);
}
private:
iterator _start;//指向数据块的初始位置
iterator _end;//指向有效数据的末尾
iterator _endofcapacity;//指向存储容量的末尾
};
}
