C++编程：vector容器的简单模拟实现

前言：

在C++标准库（STL）中，vector容器是最常见使用的动态数组。它结合了链表与数组的优点，提供了灵活的大小调整与高效的随机访问。本文将简单的对vector容器进行介绍并且对vector容器简单的模拟实现。

一、vector的文档介绍

1. vector 是表示可变大小数组的序列容器。

2. 就像数组一样， vector 也采用的连续存储空间来存储元素。也就是意味着可以采用下标对 vector 的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。

3. 本质讲， vector 使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。

4. vector 分配空间策略： vector 会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。

5. 因此， vector 占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。

6. 与其它动态序列容器相比（ deque, list and forward_list ）， vector 在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list 和 forward_list统一的迭代器和引用更好。

二、模拟实现的简单准备工作

在模拟实现之前，我们需要明确我们想要实现的基本接口。

根据https://cplusplus.com/reference/vector/vector/cplusplus网站的信息我们可以知道，vector虽然相对于string简化很多，但仍然有许多的接口，既然是简单的模拟实现，我们只需要实现最基本，常用的接口就行了。

另外，由于stl库里自带系统的vector类模板，为了区分，我们可以在自己的命名空间内完成对vector模板代码的编写。

三、模拟实现

1、vector的类参数

根据vector文档可知，本质上vector功能的正常运行大多都离不开三个指针，分别是：_start,_finish,_endOfStorage。这三个指针分别指向vector的开头，实际存储数据的末尾后一位，以及开辟的空间大小末尾，通过类函数成员对这三个参数的使用，来实现了不同的功能。

于是我们首先要定义的就是vector类模板的成员参数，注意，应该在private：下定义。

namespace MyVector
{template<class T>class vector{private:T* _start;T* _finish;T* _endOfStorage;};
}

2、类的迭代器

我们通过对vector源代码的剖析，发现，vector迭代器实际上是一个指针，于是我们可以用typedef重命名来定义我们vector的迭代器，并且为了美观，我们顺便把类的参数类型也修改为迭代器iterator。

注意，迭代器有两种类型，一种是可以修改参数的，另外一种是不能修改参数的“常量”迭代器。定义我们应该重命名两个迭代器。

namespace MyVector
{template<class T>class vector{public:typedef T* iterator;typedef const T* const_iterater;private:iterator _start;iterator _finish;iterator _endOfStorage;};
}

3、begin(),end()的实现

有了迭代器，自然会产生操控迭代器位置的一系列接口，begin，end应该是最常见的两个接口，分别返回容器的首位置，以及实际存储元素位置的下一位。

注意，这两个接口应该都有对应的返回常量迭代器的重载版本。

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

4、size，capacity的实现

我们用size返回此时存储元素的多少，capacity返回此时开辟的空间大小。

size_t size()
{return _finish - _start;
}size_t capacity()
{return _endOfStorage - _start;
}

5、reserve，push_back,pop_back的实现

根据算法的基本原理，push_back实际上本身就是检查空间是否满了，满了就先扩容，随后在确认空间足够的情况下在尾部插入元素的接口。

避免频繁扩容的问题，我们使用 reserve 预分配足够的内存。

void reserve(size_t n)
{if (n > capacity()){size_t oldsize = size();iterator tmp = new T[n];if (_start){//这里不能使用memcpy，会引发浅拷贝的一些问题for (int i = 0; i < oldsize; ++i){tmp[i] = _start[i];}delete[]_start;}_strat = tmp;_finish = _start + oldsize;_endOfStorage = _start + n;}
}void push_back(const T& x)
{if (_endOfStorage == _finish){size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();reserve(newcapacity);}*finish = x;_finish++;
}void pop_back()
{assert(size() > 0);_finish--;
}

6、构造函数，赋值重载，拷贝构造函数，析构函数，swap的实现

在大部分情况下，编译器默认生成的构造函数就足够我们使用，所以我们只需要实现拷贝构造与赋值重载函数就行了。

但是我们注意到，如果我们手动写的拷贝构造与赋值重载，编译器就不会自动生成默认的拷贝函数，为了防止这个问题，我们需要用default来强制让编译器生成。

在写赋值重载函数的时候，我们面临这一个抉择，我们可以实现现代写法swap，高效的实现赋值重载，所以，我们就需要先实现一个swap函数：

vector = default;//强制生成构造函数vector(const vector<T>& v)//拷贝构造
{reserve(v.size());for (auto it : v){push_back(it);}
}vector<T>& operator= (vector<T> v)
{swap(v);return *this;
}~vector()
{delete[]_start;_start = _finish = _endOfStorage = nullptr;
}void swap(vector<T>& v)
{std::swap(_start, v._start);std::swap(_finish, v._finish);std::swap(_endOfStorage, v._endOfStorage);
}

7、各种自定义类型迭代器的构造函数实现

我们发现，vector也支持其他自定义类型的迭代器传参，来构造。

为了接受不同的类型，所以我们又要使用模板来实现一个函数模板：

template<class InputIterator>
vector(InputIterator first, InputIterator last)//类模板中的函数模板,支持各种自定义类型的迭代器的构造
{while (first != last){push_back(*first);++first;}
}

8、[],resize的实现

为了向数组一样支持随机访问，我们需要对[]进行重载。

由于reserve()只修改capacity大小，不修改size大小，所以我们需要实现一个resize函数，既修改capacity大小，也修改size大小。

T& operator[](size_t pos)
{assert(pos < size());return _start[pos];
}const T& operator[](size_t pos)
{assert(pos < size());return _start[pos];
}void resize(size_t n, const T& value = T())//调用T类型的默认默认构造函数
{if (n < size()){_finish = _start + n;}if (n > size()){reserve(n);while (_finish != _start + n){push_back(value);}}
}

9、erase与insert的实现

erase与insert是vector容器接口中比较难实现的部分，不仅要检查是否越界，我们还要格外注意迭代器的失效问题，当然，为了解决迭代器的失效，我们需要返回新的迭代器，并在原来的使用中让原迭代器接受返回的迭代器：

 iterator insert(iterator pos, const T& x){assert(pos <= _finish);assert(pos >= _start);if (_finish == _endOfStorage){size_t oldsize = pos - _start;size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();reserve(newcapacity);pos = _start + oldsize;}iterator i = _finish - 1;while (i >= pos){*(i + 1) = *i;i--;}*pos = x;++_finish;return  pos;}iterator erase(iterator pos){assert(pos < _finish);assert(pos >= _start);iterator tmp = pos + 1;while (tmp < _finish){*(tmp - 1) = *tmp;++tmp;}--_finish;return pos;}