可以看到LInux中的g++（SGI版本的stl）使用的是重载多个vector（），但是最后都调用同一个函数。这样就避免了走模板的困扰，就很好的解决了这个问题。

2.1.5.深层次的拷贝问题。

观察代码

void reserve(size_t n){if (n > capacity()){size_t oldsize = size();iterator tmp = new T[n];if (_start){memmove(tmp, _start, sizeof(T) * oldsize);delete[] _start;}_finish = tmp + oldsize;_start = tmp;//注意这里的顺序，或者提前记录 oldsize的值。_end_of_storage = tmp + n;}}

分析是不是发现没有什么问题？
但是这个代码是不对的，为什么呢？reserve是扩容的意思，但是假设T是一个自定义类型。
比如T == vector ,这个时候tmp开好空间，直接把原空间的值（指向vetor指针)拷贝给tmp数组（vecto>,然后在delete原来的vector>,这个时候vector里面放的是一个自定义类型（vector)，就会调用自定义类型的析构函数释放掉原空间，以及原空间内容指向的空间，这个时候tmp的内容指向的空间就被释放了，tmp里面的元素指向的空间被释放了，他就是存了一系列的野指针。就会出问题。

改进

void reserve(size_t n){if (n > capacity()){size_t oldsize = size();iterator tmp = new T[n];if (_start){
1·                    //memmove(tmp, _start, sizeof(T) * oldsize);for (size_t i = 0; i < oldsize; i++){tmp[i] = _start[i];}delete[] _start;}_finish = tmp + oldsize;_start = tmp;//注意这里的顺序，或者提前记录 oldsize的值。_end_of_storage = tmp + n;}}

这样的话直接调用赋值重载，就不会涉及到浅拷贝的问题。这样tmp里面元素vector指向的空间就不同了，就很好的解决了这个问题，虽然这样写效率不高但是现在的水平只能这样写。

2.2.源码

直接上源码

vector.h

#pragma once#include
#includeusing namespace std;namespace zxf
{templateclass vector{public:typedef T* iterator;typedef const T* const_iterator;const_iterator begin()const{return _start;}    iterator begin(){return _start;}iterator end(){return _finish;}        const_iterator end()const{return _finish;}size_t size()const{//return (_finish - _start) / sizeof(T);return (_finish - _start);//注意这里对指针的正确理解}size_t capacity()const{return _end_of_storage - _start;}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():_start(nullptr), _finish(nullptr), _end_of_storage(nullptr) {}~vector(){delete[] _start;_start = nullptr;_finish = nullptr;_end_of_storage = nullptr;}templatevector(Intput frist, Intput last):_start(nullptr),_finish(nullptr),_end_of_storage(nullptr){while (frist < last){push_back(*frist);++frist;}}//拷贝构造vector(const vector& v):_start(nullptr), _finish(nullptr), _end_of_storage(nullptr){reserve(v.capacity());for (const auto& a : v)//注意这里要加引用{push_back(a);}//想一想为何要加引用。//}vector(const vector& v):_start(nullptr), _finish(nullptr), _end_of_storage(nullptr){vector tmp(v.begin(), v.end());swap(tmp);}vector& operator=(vector v)//这种写法简单//如果v1 == v1 不太好//但是也不会出错{swap(v);return *this;}//vector& operator=(const vector& v)//{//    vector tmp(v.begin(),v.end())//    swap(tmp);//    return *this;//}void reserve(size_t n){if (n > capacity()){size_t oldsize = size();iterator tmp = new T[n];if (_start){//memmove(tmp, _start, sizeof(T) * oldsize);for (size_t i = 0; i < oldsize; i++){tmp[i] = _start[i];}delete[] _start;}_finish = tmp + oldsize;_start = tmp;//注意这里的顺序，或者提前记录 oldsize的值。_end_of_storage = tmp + n;}}void push_back(const T& value){if (_end_of_storage ==  _finish){size_t newcapacity = _start == nullptr ? 4 : capacity() * 2;reserve(newcapacity);}*_finish = value;++_finish;}bool empty(){return _start == _finish;}void pop_back(){//注意判断是否为空，不能一直减，assert(!empty());--_finish;}void resize(size_t n, T value = T()){if (n > capacity()){reserve(n);}if (n < size()){_finish = _start + n;}else{while (size() != n){*_finish = value;++_finish;}}}iterator insert(iterator pos, const T& value){assert(pos <= _finish);assert(pos >= _start);size_t p = pos - _start;//注意这里迭代器失效的问题if (_finish == _end_of_storage){size_t  newcapacity = _start == nullptr ? 4 : capacity() * 2;reserve(newcapacity);}pos = _start + p;for (iterator i = _finish; i >= pos; i--){*(i + 1) = *i;}*pos = value;_finish++;return _start;}void insert(iterator pos, size_t n, const T& val){assert(pos <= _finish);assert(pos >= _start);size_t p = pos - _start;//注意也有迭代器失效问题if (_finish + n >= _end_of_storage){size_t  newcapacity = capacity() + n+2;reserve(newcapacity);}pos = _start + p;for (iterator i = _finish; i >= pos; i--){*(i + n) = *i;}int i = n;while (i--){*pos = val;pos++;}  _finish += n;}iterator erase(iterator pos){assert(pos <= _finish);assert(pos >= _start);if (_start != nullptr){for (iterator i = pos; i < _finish -1; i++){*i = *(i + 1);}}--_finish;return pos;//这里是为了个库里面保持一致}void swap(vector& v){std::swap(_start, v._start);std::swap(_finish, v._finish);std::swap(_end_of_storage, v._end_of_storage);}void clear(){_finish = _start;}private:iterator _start;iterator _finish;iterator _end_of_storage;};}