前文
vector是stl库中非常重要的一个容器,熟练使用vector可以有效提高我们的代码效率以及逼格,而模拟实现vector能使我们深入了解vector一些重要机制以及使用方法。
本文将带领铁子们完成 vector一些重要接口的实现
老规矩, 源码结尾自取。
一,vector的成员变量
![](https://i-blog.csdnimg.cn/blog_migrate/0670b8567cbba1463b4a283d229136d5.png)
首先我们可以先观察在stl30的源码中,vector的成员变量与之前的string大有不同。
由上图可以看到 三个成员变量全都是指针。
那么这些指针都代表什么意思,指向哪里呢?
start指向 空间开始的位置, finish指向 空间中最后一个有效数据的下一个位置, end_of_storage指向的是 空间最大容量的下一个位置。
![](https://i-blog.csdnimg.cn/blog_migrate/987bd8bc45055b29b0a6a376dc957b4c.png)
而我们的模拟实现vectord的成员变量自然也要向源码看齐。
当然我们后续的功能肯定是不能照搬源码的,源码只是一个参考,而我们模拟实现的目的也是更加深入的了解vector,只要实现的功能和源码的功能相同或者类似就好。
成员变量如下:
typedef V* iterator;
typedef const V* const_iterator;
iterator _start;//指向空间最开始的地址
iterator _finsh;//指向空间有效数据的下一个地址
iterator _end_of_storage;//指向空间最大容量的下一个地址
二,构造函数/析构函数
2.1 构造函数
![](https://i-blog.csdnimg.cn/blog_migrate/1b674da9238a1b7f8bac6b945e7aaf70.png)
如图,构造函数共有四种,我们要实现的是前三种。
2.1.1 无参构造函数
对于无参构造函数,我们只要将成员变量进行初始化即可。
//1.无参
vector()
:_start(nullptr)
,_finsh(nullptr)
,_end_of_storage(nullptr)
{}
2.1.2 有参构造函数
有参构造函数,我们需要先 开辟n个大小的空间,再将数据 一个一个尾插进去即可。
ps: 扩容和尾插函数后续马上就会讲到,铁子们也可以先看扩容和尾插函数,再回头看这个。
//2.有参数
vector(size_t n, const V& val = V())
:_start(nullptr)
, _finsh(nullptr)
, _end_of_storage(nullptr)
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}
//int函数重载,原因马上讲到
vector(int n, const V& val = V())
:_start(nullptr)
, _finsh(nullptr)
, _end_of_storage(nullptr)
{
reserve(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
2.1.3 范围构造函数
范围构造函数,故名思义就是构造一个范围为[first,last)的vector,然后vector中的每个数据都和范围中的数据一一对应。
实现逻辑:先 开辟和范围一样大小的空间 , 再将数据一一尾插即可 。
代码如下:
//3,范围构造
template <class InputIterator>
vector(InputIterator first, InputIterator last)
:_start(nullptr)
, _finsh(nullptr)
, _end_of_storage(nullptr)
{
size_t n = last - first;
reserve(n);
while (first != last)
{
push_back(*first);
first++;
}
}
2.1.4 函数构造适配的问题
相信老铁们已经看到有参构造函数的代码中有一个int类型的重载,那么这是为什么呢?
我们可以先将int重载代码屏蔽,然后实验一下
![](https://i-blog.csdnimg.cn/blog_migrate/9da250819bd7d7f1353e616e5ae324d8.png)
![](https://i-blog.csdnimg.cn/blog_migrate/b5a7aea036635222e766a6d7eb683fe4.png)
如上图所示,我们传的明明是有参构造的参数,为什么会出错呢?
这是因为编译器会 自动匹配最合适的函数。
有参构造函数的 参数类型为(size_t,const int)
而 范围构造函数由于 模板的问题,其参数类型会变成 (int,int)
因此系统会自动认为范围构造函数更加匹配
但是我们范围构造函数要的是地址参数,而int会导致无法解引用从而报错。
解决办法:1. 可以强转参数类型,如vector<int> s2(3u,1);将第一个参数强制转为无符号
2.就是对有参构造函数进行int类型的 函数重载
这里我们选择的是函数重载。
![](https://i-blog.csdnimg.cn/blog_migrate/43149ffd017e98d194b7d0b56fa4b65d.png)
重载后就不会出现上述问题
2.2 析构函数
vector的析构函数逻辑比较简单,释放空间资源然后置空就可以。
void test4()
{
vector<int> s2(3,1);
for (auto ch : s2)
{
cout << ch << " ";
}
cout << endl;
}
三,拷贝构造函数(重点)
拷贝构造函数的逻辑很简单,先 开辟一个同样大小的空间,再把数据一个一个挪进去。
但是挪数据一定不要用memcpy,因为mencpy属于是浅拷贝,而要拷贝的数据又有可能出现vector<string>的情况,浅拷贝析构肯定会报错的。
因为这里有一个非常重要的问题: 就是深浅拷贝的问题,由于这个问题比较复杂,后面会专门写一篇文章详解这个问题。
代码如下:
//拷贝构造
vector(const vector<V>& v)
{
_start = new V[v.capacity()];
//memcpy(_start, v._start, sizeof(V) * v.size());
for (int i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
_finsh = _start + v.size();
_end_of_storage = _start = v.capacity;
}
四,迭代器(iterator)和空间增长接口(capacity)的实现
4.1 begin()/end()
![](https://i-blog.csdnimg.cn/blog_migrate/dd839fc3eb238d54f7608716cd8a6338.png)
![](https://i-blog.csdnimg.cn/blog_migrate/a110f43329a235f82a01866ce62fd671.png)
begin和end是两个非常简单但是很实用的接口。
begin是 返回第一个数据的位置, end是 返回最后一个有效数据的下一位。
![](https://i-blog.csdnimg.cn/blog_migrate/8ec6cf15c6ef0db7f9db4cdd03139a42.png)
代码如下:
//返回begin
iterator begin()
{
return _start;
}
//返回end,迭代器访问左闭右开,所以直接返回_finsh
iterator end()
{
return _finsh;
}
//begin/end的const版本,防止出现权限扩大的问题
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finsh;
}
4.2 size()/capacity()/empty()
![](https://i-blog.csdnimg.cn/blog_migrate/0659c812d7d9a2e1af44ad45b0480022.png)
size(): 获取vector的有效数据个数。 两个地址相减可以的 得到两个数组元素的距离
capacity(): 获取vector的最大空间.
empty(): 判断是否有数据。
![](https://i-blog.csdnimg.cn/blog_migrate/beca251b8ede8106188f60f5d9df6733.png)
代码如下:
//返回容量
size_t capacity() const
{
return _end_of_storage - _start;
}
//返回有效数据个数
size_t size() const
{
return _finsh - _start;
}
//判断vector是否为空
bool empty() const
{
return _start == _finsh;
}
4.3 []重载
![](https://i-blog.csdnimg.cn/blog_migrate/bd01442ef8b875c2afd6d1751e1929be.png)
[]的实现很简单,先保证n是合法的,然后直接返回即可。
这个接口在string的时候比较常用,但vector往后大多使用迭代器访问数据。
代码如下:
//[]重载
V& operator[](size_t n)
{
assert(n < size());
return _start[n];
}
const V& operator[](const size_t n) const
{
assert(n < size());
return _start[n];
}
4.4 reserve()扩容
![](https://i-blog.csdnimg.cn/blog_migrate/841dde854d17c8a5d8b6dc7f85ae6df3.png)
实现逻辑:先检查是否需要扩容,然后用一个新的指针开空间,没问题的话,把原来空间拷贝到新空间,原空间释放,然后在给成员变量赋值。
代码如下:
void reserve(const size_t n)
{
if (n > capacity())
{
size_t sz = size();//保存size大小,防止后面_start先改变,
//导致size()计算出错从而导致_finsh出错
V* tmp= new V[n];
if (_start)
{
//memcpy(tmp, _start, sizeof(V)*sz);
for (int i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
//_finsh=tmp+size()=_start+_finsh-_start=_finsh
//如上如果不提前存储size()的值,新_finsh的值会和之前一样
_finsh = tmp + sz;
_end_of_storage = tmp + n;
}
}
注意上面有两个需要注意的点
1. size()要 提前保存起来,因为后面我们要确定_finsh的值需要原来的size(),而size的求法是_finsh-_start,如果不提前保存就会因为_start的改变无法求出准确求出size()的值,从而导致新_finsh的值出问题.
2.在往 新空间进行拷贝数据时,涉及 一个深浅拷贝的问题,后续会讲,这里要注意不能使用memcpy
4.5 resize()
![](https://i-blog.csdnimg.cn/blog_migrate/995a4e90833a16198d1e818c9ea74edb.png)
resize(): 改变vector的size。
有三种情况:1. 当n<size()时, size()要缩减到n的大小 2. 当size()<n<capacity()时, size()要扩充到n的大小,然后 中间的值用val赋值 3. 当n>capacity(),要先 扩容至n的大小,然后 重复2.
代码如下:
//resize
void resize(const size_t n, const V& val = V())//这里用V()作为缺省参数有两个原因
//1.V有可能是自定义类型,如string等
//2.因为模板的实现,所以内置类型也有构造函数
{
if (n < size())
{
_finsh = _start + n;
}
else
{
if (n > capacity())
{
reserve(n);
}
while (_finsh != _start + n)
{
(*_finsh) = val;
_finsh++;
}
}
}
老铁看到上面代码肯定有一个很疑惑的点,为什么 val=V(),而不是0或者其他。
这是因为,vector中存的类型有可能是 自定义类型,如string等,所以需要 调用其构造函数。
那可能有的同学又疑惑了,那内置类型呢?有构造函数吗?
答案肯定是有的,因为模板的特性,内置类型的构造函数也是有的,如下
![](https://i-blog.csdnimg.cn/blog_migrate/28a4337c9ce50be02947d242d3f6fef2.png)
那么问题到这里就结束了吗?不是的。
众所周知, V()作为匿名函数,其生命周期只有一行,那么是怎么延长到整个函数作用域的呢?
这里我们规定 V()生命周期只有一行是因为没名字没人用,但是const V& val会延长V()的生命周期至引用对象val的生命周期。
ps:必须带有const引用,因为V()作为常量有不可变性,如果不用const修饰,属于权限放大,会报错。
五,增删查改(Modifiers)
5.1 push_back(尾插)/pop_back(尾删)
![](https://i-blog.csdnimg.cn/blog_migrate/845d1c5bc03cd953f473b43efe209cac.png)
尾插,先检查 是否需要扩容,这里的 capacity()有可能是0,所以如果进行的是二倍扩容,需要考虑capacity()为0的情况,扩容后在 尾部插入数据就行。
![](https://i-blog.csdnimg.cn/blog_migrate/50f4bfcf57408c3ea685a928f3700d2e.png)
尾删,尾部直接删即可.
代码如下:
//尾插
void push_back(const V& val)
{
if (size() + 1 > capacity())
{
reserve(capacity() == 0 ? 4 : capacity()*2);//容量为0,要先开辟初始空间
}
*_finsh = val;
_finsh++;
}
//尾删
void pop_back()
{
assert(!empty());//判空
_finsh--;
}
5.2 insert(插入)/erase(删除)(重点)
insert和erase是vector相当重要的一部分,因为这里会涉及到 迭代器失效的问题,这个问题后续我们会和深浅拷贝放到一起讲
![](https://i-blog.csdnimg.cn/blog_migrate/0661b4409d829e4cc07bbf4d1ec9db46.png)
![](https://i-blog.csdnimg.cn/blog_migrate/512b3f5452d8815977a4b226e02464a4.png)
insert:我们实现的是第一种, 在pos的位置插入数据val
实现逻辑:1.首先需要 判断pos是否合法。
2.判断 是否需要扩容,这里需要注意的一点是扩容后会重新开辟空间,而pos指向的还是原来空间,所以需要更新
![](https://i-blog.csdnimg.cn/blog_migrate/c9e8d44932510404f47218ad7dbad60a.png)
3.从pos 开始往后的每个数据往后挪一个单位,这里不像string注意的点比较多,这里只要实现就可以
4.挪完 赋值即可
erase:我们要实现的是第一种, 删除pos位置的数据
实现逻辑:判断pos 是否合法,然后pos 往后的数据往前挪一个单位即可
代码如下:
//erase
iterator erase(iterator pos)
{
assert(pos <= _finsh && pos >= _start);
iterator end = pos;
while (end < _finsh - 1)
{
*end = *(end + 1);
end++;
}
_finsh--;
return pos;
}
五,源码
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;
namespace mjw
{
template <class V>
class vector
{
public:
//定义迭代器
typedef V* iterator;
typedef const V* const_iterator;
//构造函数
//1.无参
vector()
:_start(nullptr)
,_finsh(nullptr)
,_end_of_storage(nullptr)
{}
//2.有参数
vector(size_t n, const V& val = V())
:_start(nullptr)
, _finsh(nullptr)
, _end_of_storage(nullptr)
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}
vector(int n, const V& val = V())
:_start(nullptr)
, _finsh(nullptr)
, _end_of_storage(nullptr)
{
reserve(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
//3,范围构造
template <class InputIterator>
vector(InputIterator first, InputIterator last)
:_start(nullptr)
, _finsh(nullptr)
, _end_of_storage(nullptr)
{
size_t n = last - first;
reserve(n);
while (first != last)
{
push_back(*first);
first++;
}
}
//拷贝构造
vector(const vector<V>& v)
{
_start = new V[v.capacity()];
//memcpy(_start, v._start, sizeof(V) * v.size());
for (int i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
_finsh = _start + v.size();
_end_of_storage = _start = v.capacity;
}
//析构函数
~vector()
{
delete[] _start;
_start = _finsh = _end_of_storage = nullptr;
}
//返回begin
iterator begin()
{
return _start;
}
//返回end,迭代器访问左闭右开,所以直接返回_finsh
iterator end()
{
return _finsh;
}
//begin/end的const版本,防止出现权限扩大的问题
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finsh;
}
//返回容量
size_t capacity() const
{
return _end_of_storage - _start;
}
//返回有效数据个数
size_t size() const
{
return _finsh - _start;
}
//判断vector是否为空
bool empty() const
{
return _start == _finsh;
}
//[]重载
V& operator[](size_t n)
{
assert(n < size());
return _start[n];
}
const V& operator[](const size_t n) const
{
assert(n < size());
return _start[n];
}
//扩容函数
void reserve(const size_t n)
{
if (n > capacity())
{
size_t sz = size();//保存size大小,防止后面_start先改变,
//导致size()计算出错从而导致_finsh出错
V* tmp= new V[n];
if (_start)
{
//memcpy(tmp, _start, sizeof(V)*sz);
for (int i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finsh = tmp + sz;
_end_of_storage = tmp + n;
}
}
//resize
void resize(const size_t n, const V& val = V())//这里用V()作为缺省参数有两个原因
//1.V有可能是自定义类型,如string等
//2.因为模板的实现,所以内置类型也有构造函数
{
if (n < size())
{
_finsh = _start + n;
}
else
{
if (n > capacity())
{
reserve(n);
}
while (_finsh != _start + n)
{
(*_finsh) = val;
_finsh++;
}
}
}
//尾插
void push_back(const V& val)
{
if (size() + 1 > capacity())
{
reserve(capacity() == 0 ? 4 : capacity()*2);//容量为0,要先开辟初始空间
}
*_finsh = val;
_finsh++;
}
//尾删
void pop_back()
{
assert(!empty());//判空
_finsh--;
}
//insert
iterator insert(iterator pos, const V& val)
{
assert(pos <= _finsh&&pos>=_start);
//判断扩容
if (size() + 1 > capacity())
{
//由于扩容会重新开辟空间,原有的pos会失效
//所以需要保存pos的相对位置,方便在新空间定位
size_t p = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);//容量为0,要先开辟初始空间
//新空间pos
pos = _start + p;
}
//从pos开始往后的每个数据往后挪一个单位
iterator end = _finsh - 1;
while (end >= pos)
{
*(end + 1) = *end;
end--;
}
*pos = val;
_finsh++;
return pos;
}
//erase
iterator erase(iterator pos)
{
assert(pos <= _finsh && pos >= _start);
iterator end = pos;
while (end < _finsh - 1)
{
*end = *(end + 1);
end++;
}
_finsh--;
return pos;
}
private:
iterator _start;//指向空间最开始的地址
iterator _finsh;//指向空间有效数据的下一个地址
iterator _end_of_storage;//指向空间最大容量的下一个地址
};
//下面是测试函数
void test1()
{
vector<int> s1;
s1.resize(5, 0);
for (auto ch : s1)
{
cout << ch << " ";
}
cout << endl;
}
void test2()
{
vector<int> s1;
s1.push_back(1);
s1.push_back(2);
s1.push_back(3);
s1.push_back(4);
s1.push_back(5);
for (auto ch : s1)
{
cout << ch << " ";
}
cout << endl;
s1.pop_back();
s1.pop_back();
s1.pop_back();
s1.pop_back();
s1.pop_back();
s1.pop_back();
for (auto ch : s1)
{
cout << ch << " ";
}
cout << endl;
}
void test3()
{
vector<int> s1;
s1.insert(s1.begin(), 1);
s1.insert(s1.begin(), 2);
s1.insert(s1.begin(), 3);
s1.insert(s1.begin(), 4);
s1.insert(s1.begin(), 5);
for (auto ch : s1)
{
cout << ch << " ";
}
cout << endl;
s1.erase(s1.begin());
s1.erase(s1.begin());
s1.erase(s1.begin());
s1.erase(s1.begin());
for (auto ch : s1)
{
cout << ch << " ";
}
cout << endl;
}
void test4()
{
vector<int> s2(3,1);
for (auto ch : s2)
{
cout << ch << " ";
}
cout << endl;
}
void test5()
{
int a = int();
double b = double();
cout << a << endl;
cout << b << endl;
}
};
总结
vector的重要功能算是已经完成模拟实现,相信铁子们对vector也有了更深入的理解,
同时这里面还有两个问题,我们没有解决: 1.深浅拷贝的问题 2.迭代器失效的问题
后续 近两天就会出一篇文章详解这两个问题,铁子们敬请期待。