前言
本篇博客为大家介绍vector的模拟实现，前面我们已经了解了vector的使用，现在我们来从底层的角度去模拟实现vector，这里说明一下，我们只实现一些核心接口，模拟实现的目的就是让我们更深入地了解和掌握vector，毕竟我们不可能实现得比库里还全面，下面进入正文部分。
1.vector各函数接口总览
namespace cl
{
//模拟实现vector
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
//默认成员函数
vector(); //构造函数
vector(size_t n, const T& val); //构造函数
template<class InputIterator>
vector(InputIterator first, InputIterator last); //构造函数
vector(const vector<T>& v); //拷贝构造函数
vector<T>& operator=(const vector<T>& v); //赋值运算符重载函数
~vector(); //析构函数
//迭代器相关函数
iterator begin();
iterator end();
const_iterator begin()const;
const_iterator end()const;
//容量和大小相关函数
size_t size()const;
size_t capacity()const;
void reserve(size_t n);
void resize(size_t n, const T& val = T());
bool empty()const;
//修改容器内容相关函数
void push_back(const T& x);
void pop_back();
void insert(iterator pos, const T& x);
iterator erase(iterator pos);
void swap(vector<T>& v);
//访问容器相关函数
T& operator[](size_t i);
const T& operator[](size_t i)const;
private:
iterator _start; //指向容器的头
iterator _finish; //指向有效数据的尾
iterator _endofstorage; //指向容器的尾
};
}
注：为了防止与标准库当中的vector产生命名冲突，模拟实现时需放在自己的命名空间当中。
2.vector成员变量介绍
大家看到上面模拟实现的vector中有三个成员变量，这里统一说明一下它们的含义：
_start指向容器的头，_finish指向容器当中有效数据的尾，_endofstorage指向整个容器的尾。
其实大家可以结合前面学过的顺序表来进行理解，这里是_finish可以类比于size，_endofstorage相当于capacity。
3. 默认成员函数
3.1 构造函数
3.1.1 构造函数1
vector首先支持一个无参的构造函数，对于这个无参的构造函数，我们直接将构造对象的三个成员变量都设置为空指针即可。
//构造函数1
vector()
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{}
3.1.2 构造函数2
vector还支持使用一段迭代器区间进行对象的构造。
因为该迭代器区间可以是其他容器的迭代器区间，也就是说该函数接收到的迭代器的类型是不确定的，所以我们这里需要将该构造函数设计为一个函数模板，在函数体内将该迭代器区间的数据一个个尾插到容器当中即可。
//构造函数2
template<class InputIterator> //模板函数
vector(InputIterator first, InputIterator last)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
//将迭代器区间在[first,last)的数据一个个尾插到容器当中
while (first != last)
{
push_back(*first);
first++;
}
}
3.1.3 构造函数3
此外，vector还支持构造这样一种容器，该容器当中含有n个值为val的数据。对于该构造函数，我们可以先使用reserve函数将容器容量先设置为n，然后使用push_back函数尾插n个值为val的数据到容器当中即可。
//构造函数3
vector(size_t n, const T& val)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(n); //调用reserve函数将容器容量设置为n
for (size_t i = 0; i < n; i++) //尾插n个值为val的数据到容器当中
{
push_back(val);
}
}
3.2 拷贝构造函数
使用范围for（或是其他遍历方式）对容器v进行遍历，在遍历过程中将容器v中存储的数据一个个尾插过来即可。
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(v.capacity()); //调用reserve函数将容器容量设置为与v相同
for (auto e : v) //将容器v当中的数据一个个尾插过来
{
push_back(e);
}
}
注意： 将容器当中的数据一个个拷贝过来时不能使用memcpy函数，当vector存储的数据是内置类型或无需进行深拷贝的自定义类型时，使用memcpy函数是没什么问题的，但当vector存储的数据是需要进行深拷贝的自定义类型时，使用memcpy函数的弊端就体现出来了。
例如，当vector存储的数据是string类的时候。
并且vector当中存储的每一个string都指向自己所存储的字符串。
如果此时我们使用的是memcpy函数进行拷贝构造的话，那么拷贝构造出来的vector当中存储的每个string的成员变量的值，将与被拷贝的vector当中存储的每个string的成员变量的值相同，即两个vector当中的每个对应的string成员都指向同一个字符串空间。
这显然不是我们得到的结果，那么所给代码是如何解决这个问题的呢？
代码中调用了所存元素的赋值运算符重载函数，而string类的赋值运算符重载函数就是深拷贝，所以拷贝结果是这样的：
总结一下： 如果vector当中存储的元素类型是内置类型（int）或浅拷贝的自定义类型（Date），使用memcpy函数进行进行拷贝构造是没问题的，但如果vector当中存储的元素类型是深拷贝的自定义类型（string），则使用memcpy函数将不能达到我们想要的效果。
3.3 赋值运算符重载函数
首先在右值传参时并没有使用引用传参，因为这样可以间接调用vector的拷贝构造函数，然后将这个拷贝构造出来的容器v与左值进行交换，此时就相当于完成了赋值操作，而容器v会在该函数调用结束时自动析构。
vector<T>& operator=(vector<T> v) //编译器接收右值的时候自动调用其拷贝构造函数
{
swap(v); //交换这两个对象
return *this; //支持连续赋值
}
3.4 析构函数
对容器进行析构时，首先判断该容器是否为空容器，若为空容器，则无需进行析构操作，若不为空，则先释放容器存储数据的空间，然后将容器的各个成员变量设置为空指针即可。
//析构函数
~vector()
{
if (_start) //避免对空指针进行释放
{
delete[] _start; //释放容器存储数据的空间
_start = nullptr; //_start置空
_finish = nullptr; //_finish置空
_endofstorage = nullptr; //_endofstorage置空
}
}
4. 迭代器相关函数
vector当中的迭代器实际上就是容器当中所存储数据类型的指针。
typedef T* iterator;
typedef const T* const_iterator;
4.1 begin和end
vector当中的begin函数返回容器的首地址，end函数返回容器当中有效数据的下一个数据的地址。
iterator begin()
{
return _start; //返回容器的首地址
}
iterator end()
{
return _finish; //返回容器当中有效数据的下一个数据的地址
}
我们还需要重载一对适用于const对象的begin和end函数，使得const对象调用begin和end函数时所得到的迭代器只能对数据进行读操作，而不能进行修改。
const_iterator begin()const
{
return _start; //返回容器的首地址
}
const_iterator end()const
{
return _finish; //返回容器当中有效数据的下一个数据的地址
}
此时再让我们来看看vector使用迭代器的代码也就一目了然了，实际上就是使用指针遍历容器。
vector<int> v(5, 3);
vector<int>::iterator it = v.begin();
while (it != v.end())
{
cout << *it << " ";
it++;
}
cout << endl;
现在我们实现了迭代器，实际上也就可以使用范围for遍历容器了，因为编译器在编译时会自动将范围for替换为迭代器的形式。
vector<int> v(5, 3);
//范围for进行遍历
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
5. 容量和大小相关函数
5.1 size和capacity
size_t size()const
{
return _finish - _start; //返回容器当中有效数据的个数
}
size_t capacity()const
{
return _endofstorage - _start; //返回当前容器的最大容量
}
5.2 reserve
reserve规则：
1、当n大于对象当前的capacity时，将capacity扩大到n或大于n。
2、当n小于对象当前的capacity时，什么也不做。
void reserve(size_t n)
{
if (n > capacity()) //判断是否需要进行操作
{
size_t sz = size(); //记录当前容器当中有效数据的个数
T* tmp = new T[n]; //开辟一块可以容纳n个数据的空间
if (_start) //判断是否为空容器
{
for (size_t i = 0; i < sz; i++) //将容器当中的数据一个个拷贝到tmp当中
{
tmp[i] = _start[i];
}
delete[] _start; //将容器本身存储数据的空间释放
}
_start = tmp; //将tmp所维护的数据交给_start进行维护
_finish = _start + sz; //容器有效数据的尾
_endofstorage = _start + n; //整个容器的尾
}
}
1. 在进行操作之前需要提前记录当前容器当中有效数据的个数。
因为我们最后需要更新_finish指针的指向，而_finish指针的指向就等于_start指针加容器当中有效数据的个数，当_start指针的指向改变后我们再调用size函数通过_finish - _start计算出的有效数据的个数就是一个随机值了。
2. 拷贝容器当中的数据时，不能使用memcpy函数进行拷贝。
释放原容器空间的时候，原容器当中存储的每个string在释放时会调用string的析构函数，将其指向的字符串也进行释放，所以使用memcpy函数reserve出来的容器当中的每一个string所指向的字符串实际上是一块已经被释放的空间，访问该容器时就是对内存空间进行非法访问。
5.3 resize
resize规则：
1、当n大于当前的size时，将size扩大到n，扩大的数据为val，若val未给出，则默认为容器所存储类型的默认构造函数所构造出来的值。
2、当n小于当前的size时，将size缩小到n。
void resize(size_t n, const T& val = T())
{
if (n < size()) //当n小于当前的size时
{
_finish = _start + n; //将size缩小到n
}
else //当n大于当前的size时
{
if (n > capacity()) //判断是否需要增容
{
reserve(n);
}
while (_finish < _start + n) //将size扩大到n
{
*_finish = val;
_finish++;
}
}
}
注意： 在C++当中内置类型也可以看作是一个类，它们也有自己的默认构造函数，所以在给resize函数的参数val设置缺省值时，设置为T( )即可。
5.4 empty
bool empty()const
{
return _start == _finish;
}
6. 修改容器内容相关函数
6.1 push_back
要尾插数据首先得判断容器是否已满，若已满则需要先进行增容，然后将数据尾插到_finish指向的位置，再将_finish++即可。
void push_back(const T& x)
{
if (_finish == _endofstorage) //判断是否需要增容
{
size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity(); //将容量扩大为原来的两倍
reserve(newcapacity); //增容
}
*_finish = x; //尾插数据
_finish++; //_finish指针后移
}
6.2 pop_back
尾删数据之前也得先判断容器是否为空，若为空则做断言处理，若不为空则将_finish–即可。
//尾删数据
void pop_back()
{
assert(!empty()); //容器为空则断言
_finish--; //_finish指针前移
}
6.3 insert
insert函数可以在所给迭代器pos位置插入数据，在插入数据前先判断是否需要增容，然后将pos位置及其之后的数据统一向后挪动一位，这里注意是从后往前进行挪动，以留出pos位置进行插入，最后将数据插入到pos位置即可。
//在pos位置插入数据
void insert(iterator pos, const T& x)
{
if (_finish == _endofstorage) //判断是否需要增容
{
size_t len = pos - _start; //记录pos与_start之间的间隔
size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity(); //将容量扩大为原来的两倍
reserve(newcapacity); //增容
pos = _start + len; //通过len找到pos在增容后的容器当中的位置
}
//将pos位置及其之后的数据统一向后挪动一位，以留出pos位置进行插入
iterator end = _finish-1;
while (end >= pos)
{
*(end+1) = *end;
end--;
}
*pos = x; //将数据插入到pos位置
_finish++; //数据个数增加一个，_finish后移
}
6.4 erase
erase函数可以删除所给迭代器pos位置的数据，在删除数据前需要判断容器释放为空，若为空则需做断言处理，删除数据时直接将pos位置之后的数据统一向前挪动一位，这里注意是从前往后挪动，将pos位置的数据覆盖即可。
//删除pos位置的数据
void erase(iterator pos)
{
assert(!empty()); //容器为空则断言
//将pos位置之后的数据统一向前挪动一位，以覆盖pos位置的数据
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;
it++;
}
_finish--; //数据个数减少一个，_finish前移
}
6.5 swap
swap函数用于交换两个容器的数据，我们可以直接调用库当中的swap函数将两个容器当中的各个成员变量进行交换即可。
//交换两个容器的数据
void swap(vector<T>& v)
{
//交换容器当中的各个成员变量
::swap(_start, v._start);
::swap(_finish, v._finish);
::swap(_endofstorage, v._endofstorage);
}
7. 访问容器相关函数
7.1 operator[ ]
T& operator[](size_t i)
{
assert(i < size()); //检测下标的合法性
return _start[i]; //返回对应数据
}
const T& operator[](size_t i)const
{
assert(i < size()); //检测下标的合法性
return _start[i]; //返回对应数据
}
注意： 重载运算符[ ]时需要重载一个适用于const容器的，因为const容器通过“下标+[ ]”获取到的数据只允许进行读操作，不能对数据进行修改。
8. 总结
本篇博客为大家介绍了vector的模拟实现，上面实现了vector的一些核心接口，大家需要掌握一下，以便于更深入掌握vector，模拟实现就是从底层去学习vector，我们可以通过模拟实现更清楚地看到vector的构造原理，最后，希望本篇博客可以为大家带来帮助，感谢阅读！
扫一扫
3829
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
