std::vector的模拟实现

构造函数

无参构造

用n个val来初始化的拷贝构造

拷贝构造

用迭代器初始化

析构函数

reserve

resize

pushback

pop_back

迭代器及解引用

迭代器的实现

解引用[ ]

insert

erase

赋值拷贝

补充

vector底层也是顺序表，但是vector可以储存不同的类型包括自定义类型和内置类型，所以在实现vector的时候要用模板实现。vector的成员变量与string是不同的，vector的成员变量是3个迭代器，分别是指向顺序表起始位置的指针，指向最后一个数据下一个位置的指针以及指向尾部开辟的空间。

namespace cfl
{template<class T>class vector{typedef T* iterator;public:private:iterator _start;      //指向顺序表的开头iterator _finish;     //指向顺序表最后一个有效数据的下一个位置iterator _end_of_storage;	//指向最后一个开辟的空间的下一个位置};
}

构造函数

vector的构造函数有5个，我们先实现4个，有一个涉及到容器分配器在写容器篇博客时会实现。

无参构造

//无参构造
vector():_start(nullptr),_finish(nullptr),_end_of_storage(nullptr)
{}

用n个val来初始化的拷贝构造

//用n个val来初始化的拷贝构造
vector(size_t n, const T& val)
{_start = new T[n];for (int i = 0; i < n; i++)_start[i] = val;_finish = _start + n;_end_of_storage = _start + n;
}

拷贝构造

注意在进行拷贝构造的时候，不建议使用memcpy，因为在使用memcpy的时候内置类型不会出问题，但是对于自定义类型可能会出现浅拷贝，自定义类型中有指针就只是简单的拷贝其地址，导致两个vector指向同一块位置，就会调用两次析构函数。

size_t size()const
{return _finish - _start;
}size_t capacity()const
{return _end_of_storage - _start;
}//拷贝构造
vector(const vector& v)
{_start = new T[v.capacity()];//memcpy(_start, v._start, v.size()*sizeof(T));用memcpy，如果T是自定义类型可能会导致浅拷贝比如T是string，则指挥拷贝string的地址，导致两个vector指向一个位置//用for循环和赋值运算符重载来实现for (int i = 0; i < v.size(); i++){_start[i] = v._start[i];}_finish = _start + v.size();_end_of_storage = _start + v.capacity();
}

用迭代器初始化

此处使用迭代器初始化为了方便直接调用push_back(在后面实现)。

//用迭代器初始化
template<class InputIterator>  //此处用一个函数迭代器，使得vector可以用各种类型初始化，能用int数组也能用string等
vector(InputIterator first, InputIterator last)
{//直接调用push_back让其去开辟空间while (first != last){push_back(*first);++first;}
}

析构函数

~vector()
{delete[] _start;_start = _finish = _end_of_storage = nullptr;
}

reserve

用reserve进行空间的开辟，与拷贝构造同理，这里也不建议使用memcpy进行拷贝。

void reserve(size_t n)
{if (n > capacity()){iterator tmp = new T[n];int sz = size();for (int i = 0; i < sz; i++){tmp[i] = _start[i];}delete[] _start;_start = tmp;_finish = _start + sz;_end_of_storage = _start + n;}
}

resize

resize传参时如果小于size()，就会对空间进行缩小，如果大于就会额外对额外的空间进行初始化。

void resize(size_t n,const T& val=T()) //如果没有传val就用编译器默认的初始化
{if (n < size()){_finish = _start + n;}else{reserve(n);while (_finish != _end_of_storage){*(_finish) = val;++_finish;}}
}

pushback

void push_back(const T& val)
{if (_finish == _end_of_storage){reserve(capacity() == 0 ? 4 : 2 * capacity());}*(_finish) = val;++_finish;
}

pop_back

尾删。

void pop_back()
{_finish--;
}

迭代器及解引用

迭代器的实现

对于迭代器的实现就是实现begin和end。

迭代器的实现也分为两种：非const版本和const版本。

iterator begin()
{return _start;
}
iterator end()
{return _finish;
}typedef const T* const_iterator;
const_iterator begin()const
{return _start;
}
const_iterator end()const
{return _finish;
}

解引用[ ]

//解引用运算符重载
T& operator[](size_t pos)
{assert(pos < size());return _start[pos];
}

insert

insert插入。insert传的pos是在_start和_finish之间的，所以在扩容后对导致_start指向新的空间了，但是pos位置还指向原位置，所以扩容后要对pos位置进行更新。

void insert(iterator pos, const T& val)
{assert(pos < _finish);if (_finish == _end_of_storage){int num = pos - _start;  //如果想开辟空间，会导致_start指向新的位置但是pos还指向原处reserve(2 * capacity());pos = _start + num; //对pos位置进行更新}iterator end = _finish;while (end > pos){*(end) = *(end - 1);--end;}*pos = val;++_finish;
}

insert后不能再使用pos这个迭代器了，因为他可能失效。可以用一个返回值来返回新的pos位置。

erase

指定位置删除。

void erase(iterator pos)
{iterator cur = pos;while (cur + 1 < _finish){*(cur) = *(cur + 1);++cur;}--_finish;
}

赋值拷贝

void swap(T& tmp)
{swap(this->_start, tmp._start);swap(this->_finish, tmp._finish);swap(this->_end_of_storage, tmp._end_of_storage);
}//赋值拷贝
T& operator=(T tmp)
{swap(tmp);
}

此处赋值拷贝还是使用交换临时变量的方法，即能够将tmp拷贝构造的空间给this还能让tmp去销毁this的原本数据。