目录
大致框架
namespace zbw
{
template <class T>
class vector
{
public:
typedef T* iterator;
private:
iterator _start;
iterator _finish;
iterator _end_of_storage;
};
}
1.构造函数
（1）无参构造
vector()
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{}（2）构造n个val
vector(size_t n,const T& val = T())//const延长匿名对象的生命周期
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
reverse(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
匿名对象生命周期只有这一行，调用完匿名函数后会调用析构函数将其析构
但引用会延长匿名对象的生命周期到引用对象域结束，由于匿名对象具有常性，所以需要用const修饰，此时调用完匿名对象，并不会调用析构函数释放
（3）用迭代器构造初始化函数
tmplete <class InputIterator>
vector(InputIterator first,InputIterator last)
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
while (first != last)
{
push_back(*first);
first++;
}
}使用迭代器模板，就可以传任意类型的迭代器，否则只能使用vector的迭代器
起名为InputIterator,是因为函数模板的模板参数要传迭代器区间时，是存在命名规范的
InputIterator这种迭代器所指的对象为“只读”，不允许外界更改
（4）拷贝构造函数
传统写法
vector(const vector<T>& v)//v2(v1)
{
_start = new T[v.capacity()];
_finish = _start + v._size();
_end_of_storage = _start + v._capacity;
memcpy(_start, v._start, v.size() * sizeof(T));
}开一块和v1一样大的空间，再把v1的数据拷贝到新空间里去
现代写法
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(const vector<T>& v)//v2(v1)
{
vector<T> tmp(v.begin(), v.end());
swap(tmp);
}利用迭代器初始化的构造函数，用v1创造一个临时变量tmp，再将v2与tmp交换，tmp出了作用域就调用析构函数销毁
最终版本：（防止浅拷贝）
vector(const vector<T>& v)//拷贝构造
{
reserve(v.capacity());
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];//使用默认的赋值运算符会发生浅拷贝
}
_finish = _start + v.size();
}
2.operator=
现代写法
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=(const vector<T> v)//v3 = v1
{
swap(v);
return *this;
}利用传值传参拷贝构造v（此时v就是v1），再将v3与v1交换，v是临时对象除了作用域会调用析构函数销毁
3.operator[]
T& operator[](size_t i)
{
assert(i < size())