鉴于读者的响应，打算将文章拆分一下，方便观看，基本接口可看 深入浅出STL之vector类
一、源码引入
- 以下我所介绍的都是基于【SGI】版本的STL，对源码有兴趣的同学可以去看看 侯捷老师的《STL源码剖析》
- 然后呢我们就去调出【vector】的一些核心源码，这里我们主要关注的就是这个使用原生指针
value_type*所定义出来的迭代器iterator - 然后我们又看到了保护成员：
[start]、[finish]、[end_of_stroage]。看到它们你是否有想起我们在 模拟string 的时候写到过的[a]、[size]、[capacity]；没错，它们就存在着一定的对应关系
- 但是呢，只看上面这些成员变量还不够，我们要将其带入到具体的场景中，例如下面有两个接口分别为【尾插】和【扩容】，对于
push_back()封装得没有那么厉害，读者结合下面的图应该就能看得懂，分别就是 未满追加的逻辑和已满扩容的逻辑 - 那对于
reserve()来说，就是一个扩容的逻辑，【allocate_and_copy】是开辟和拷贝空间，那【deallocate】就是释放空间。在扩完容之后不要忘了去对三个成员变量做更新，这一块的模拟实现我在下面马上就会讲到
- 最后的话我们再来看看 构造函数
construct和析构函数destroy，光看代码，不知你是否回忆起了我们曾经在 C/C++内存管理 中有讲到【定位new】这个概念，而且提到了 内存池 这个概念 - 其实我们在调用构造函数的时候，都是通过【空间适配器】在 内存池 中开出空间；那在出了作用域之后这些所开的空间都要销毁了，所以就会去调用析构函数完成释放
💬 对于上面的这些源码呢，读者可以在学习了STL一段时间后，配合侯捷老师的《STL源码剖析》再去展开阅读，因为考虑到读者的基础，就不在继续深入讲解了~
二、模拟实现
然后我们就来模拟实现一下【vector】中的各种接口
- 还是一下，我们先简述一下整体的架构。这个
vector类还是包在【bit】这个命名空间中，而对于这个类而言，我要将其定义为一个 模版类，这一块如果还有同学不太熟悉的话可以去看看 C++模版 - 其他部分可以看到迭代器我定义的就是原生指针类型，然后将
[_start]、[_finish]、[_end_of_storage]也定义为了三个迭代器类型，并且采用提前声明的形式将它们都初始化为nullptr，这样当我们后面在写 构造函数和析构函数 的时候就不需要再去做初始化了
namespace bit {
template<class T>
class vector {
public:
typedef T* iterator;
typedef const T* const_iterator;
// 主要接口函数
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _end_of_storage = nullptr;
};
}
1、迭代器
- 首先的话简单一点，来实现一下迭代器，分为
非const版本和const版本
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
2、容量
- 然后我们来讲讲容量相关的接口，首先的话就是【size】和【capacity】这两个接口
size_t size()
{
return _finish - _start;
}
size_t capacity()
{
return _end_of_storage - _start;
}
- 对于【size】而言指的是当前这个容器中的数据个数，那也就是我们在上面所讲的
_start和_finish这两个迭代器之间的距离，我们之前有说到过迭代器它的底层其实就是指针，那要计算出两个指针之间的数据个数的话让它们做一个相减_finish - _start - 那对于整个容器的容量【capacity】来说，即为
_end_of_storage - _start。读者通过下图便可一目了然地看出来
- 然后呢再来说说扩容这一块的接口【reserve】，首先在一进来的时候我们要去做一个判断，只有当所传入的值要比原先的
capacity()来得大的时候，我们才去执行一个扩容的逻辑，在内部的扩容逻辑中可以看到我们使用到了前面所定义的模版参数T，这样去写的话就可以根据不同的类型参数开出不同的空间 - 接下去我们所执行的就是拷贝的逻辑，采取到的是内存函数
memcpy()，拷贝完后再去释放原空间，接下去把这些成员变量去做一个更新即可
看着逻辑很清晰，但是呢下面的代码存在着非常多的漏洞
void reserve(size_t n)
{
if (n > capacity())
{
T* tmp = new T[n]; // 开一块新空间
if (_start)
{
memcpy(tmp, _start, sizeof(T) * size());
delete[] _start;
}
_start = tmp;
_finish = _start + size();
_end_of_storage = _start + n;
}
}
- 我们这里再写一个
push_back的接口（后面讲），让代码先跑起来
void push_back(const T& x)
{
if (_finish == _end_of_storage)
{
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
}
*_finish = x;
_finish++;
}
💻第一轮测试 — 空指针异常
下面是测试的代码
void test_vector1()
{
bit::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
- 但是呢在运行起来后却发现程序出现了崩溃，这是为什么呢？
- 按下【F5】以调试的方式运行起来就可以发现有地方出现了 空指针异常
- 进一步，我们通过【调试窗口】再来看看，很明显得就看到这个
_finish的值为【0x00000000】
- 知道了问题所在，接下去我们就通过调试一步步地来看。虽然这个代码是崩在
191，但是呢其实真正的问题还是出在【reserve】这个扩容的逻辑中，随着我们一步一步地去看，可以看到_start和_end_of_storage这两个都没什么问题，但是_finish就是没有什么变化，所以呢我们可以锁定到下面这句话
_finish = _start + size();
- 此时就需要去看看这个【size】了，之前我们使用的是
_finish - _start来计算的 size()，在执行这句话时_start已经发生了改变，因为我们去开出了一块新的空间，但是这时_finish的值还是一开始的【nullptr】，那么这个 size() 最后计算出来的大小即为-_start，此时再和_start去做一个结合的话即为 0
💬 所以，上述就是为什么这个_finish的值为【0x00000000】原因，那我们要如何去修改呢？
- 首先第一种解决方案，就是先去更新这个
_finish，用开出空间的 tmp 去做一个更新，然后再用 tmp 去更新_start，这样就不会出现问题了
_finish = tmp + size();
_start = tmp;
_end_of_storage = _start + n;
- 通过调试来观察看看就发现确实不为空了
💬 但是呢上面这种方案的话可能你的徒弟在维护你的代码的时候就会觉得很奇怪，又给改回去了，导致原先的问题再度发生，所以我们可以采取下面这种策略
- 我们可以在每次没开始扩容之前我们都可以去事先保存一下这个 size()，后面的更新顺序就不需要发生变动了，在加的时候加上
sz即可
if (n > capacity())
{
// 先保存一下原先的size()
size_t sz = size();
T* tmp = new T[n]; // 开一块新空间
if (_start)
{
memcpy(tmp, _start, sizeof(T) * size());
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_end_of_storage = _start + n;
}
- 通过调试再来看到确实也可以起到同样的效果
👉 但是呢这还没完，【reserve】接口还是存在问题
💻第二轮测试 — memcpy的拷贝问题
- 下面是我们要进行第二轮测试的代码，内部类型使用的是 string类
void test_vector2()
{
bit::vector<string> v;
v.push_back("11111");
v.push_back("22222");
v.push_back("33333");
v.push_back("44444");
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
- 运行起来看并没有什么问题
- 但是呢当我再去
push_back("55555")的时候程序却出现了问题
💬 那此时有的同学脑子转得很快，感觉到一定是【reserve】扩容的地方出现了问题
- 于是经过我们的排查，先定位到了这一句，有同学就觉得是不是因为每次
sizeof(T)的对象大小不一样了?
memcpy(tmp, _start, sizeof(T) * size());
我觉得上述这个老铁提出来的问题非常好，我们一起来看看。请读者思考一下下面的结果是多少
void test_vector3()
{
string s1("11111");
string s2;
string s3("222222222222222222");
cout << sizeof(s1) << endl;
cout << sizeof(s2) << endl;
cout << sizeof(s3) << endl;
}
- 如果有阅读过 深入浅出STL之string类 的同学一定可以知道在VS下对于每个string对象的大小都是固定死的，均为 28B，即使是通过不同的构造形式构造出来的对象也是一样的
接下去呢，就带读者好好地通过调试观察一下💻
v.push_back("1111111111111111");
v.push_back("2222222222222222");
v.push_back("3333333333333333");
v.push_back("4444444444444444");
v.push_back("5555555555555555");
- 如果对深浅拷贝这一块比较了解的同学一定可以知晓这里很明显地发生了一个 浅拷贝 的问题，所以导致在
delete[] _start的时候发生了一个 并发修改 的问题
- 这就导致了我们在释放原本的这块空间时导致拷贝后的这块空间也造成了另一块空间的问题
可能有的读者还是不太理解这其中的原理，我们通过画图再来看看
- 可以看到，在扩容的时候我们去开出了一块新的空间，然后使用
memcpy()将数据原封不动地拷贝到了另一块空间中，再去做了一个扩容，那在上面我们也看到过了，就是因为这个memcpy()原封不动拷贝的问题，就使得新空间和旧空间虽然是两块独立的空间，但是呢每个对象中的_str都和另一个对象指向了那一块同样的空间
- 那么在接下去在执行这句代码的时候就会先去调用当前对象的析构函数将每一块空间中的内容先清理掉，然后再去调用
delete释放掉整块空间。因为每两个对象所指向的空间都是同一块的，所以在释放的时候就会造成同时修改的问题
delete[] _start;
【总结一下】：
vector是深拷贝，但是vector空间上存的对象是string的数组，使用memcpy()导致string对象的浅拷贝
那我们要如何去避免这一种问题呢？
- 很简单，我们去换一下这个拷贝的逻辑就可以了，不要使用
memcpy()去进行浅拷贝，而是使用下面这种形式去进行拷贝 - 对于
tmp[i] = _start[i]如果对代码比较敏感的同学应该可以很快地看出这会去调用 string类 的赋值重载，然后去做一个深拷贝，此时就不会造成两个_str指向同一块空间了
for (size_t i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
- 最后通过调试再来观察一下👀
以下就是【reserve】这个接口的最终完整版实现逻辑
void reserve(size_t n)
{
if (n > capacity())
{
// 先保存一下原先的size()
size_t sz = size();
T* tmp = new T[n]; // 开一块新空间
if (_start)
{
//memcpy(tmp, _start, sizeof(T) * size());
for (size_t i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_end_of_storage = _start + n;
}
}
接下去的话我们再来看看【resize】这个接口该如何去实现
- 还是一样分为三类来进行讨论：
- 一个是
n < _finish的情况； - 第二个是
n > _finish && n <= _end_of_storage的情况； - 第三个是
n >_end_of_storage的情况；
- 一个是
- 对于后两种情况我们可以做一个合并，使用上面【reserve】去做一个容量的检查
- 我们来看一下具体的代码，首先是第一种，直接让
_finish = _start + n即可；如果是另一种情况的话，就先使用【reserve】去检查一下是否需要扩容，然后再去通过循环追加对应的数据即可
void resize(size_t n, const T& val = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
// 先使用reserve()去检查一下是否需要扩容
reserve(n);
while (_finish != _start + n)
{
*_finish = val;
_finish++;
}
}
}
- 可能有同学比较好奇这个
T()是干嘛的，还记我们在 C++缺省参数 中所讲到的知识点吗。没错，这个T()就是给到的默认缺省参数，因为当前的形参【val】的类型使用的就是模版参数类型，采取自动推导的形式去进行自动识别 - 而
T()就是我们在 类和对象小知识 中所学习过的【匿名对象】，切记这里不可以给0，因为当前的数据类型不一定就是 整型，我们就可以根据这个匿名对象去生成不同的默认值
const T& val = T()
简单地来测试一下
3、元素访问
- 对于元素访问的话我们最常用的就是
下标 + []的形式，这里给出两种，一个是const版本和非const版本
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
4、修改操作
接下去的话我们来讲讲有关修改操作的一些接口
- 首先第一个的话就是
push_back，这个我在上面讲【reserve】的时候给出过，现在仔细地再来讲一讲：首先的话我们要考虑的就是扩容的逻辑，上面我们有讲到在VS下是呈现 1.5倍 的增长趋势，但是在g++下呈现的则是 2倍 的扩容逻辑，这里的扩容的话我们就交给【reserve】来实现
void push_back(const T& x)
{
if (_finish == _end_of_storage)
{
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
}
*_finish = x;
_finish++;
}
然后的话我们来实现一下【insert】这个接口
void insert(iterator pos, const T& x)
这一块的话我们已经讲过很多遍了，要在某一个位置插入数据的话就需要先去挪动部分的数据，这里我们从后往前挪，防止造成覆盖的情况，当数据挪动完毕后，再在pos这个位置插入指定的数据即可
- 在一进入函数的时候大家可以去做一个断言的操作，不过很多同学可能会好奇这边的
pos >= _start，为什么可以位于首部
assert(pos >= _start && pos <= _finish);
💬 在讲解 string类 的时候我们确实讲到了这种写法的缺陷，但是读者要看清楚了，这里pos的类型是 iterator，为一个迭代器。而我们在 string类 中所讲到的这个pos呢是一个无符号整数
- 位于首部的迭代器
pos不可能是0，因为它是一段空间的地址，有效空间的地址不可能是0，
string& insert (size_t pos, const string& str);
- 不过呢，既然是插入数据的话就一定会存在容量不足的情况，此时就需要一个扩容逻辑，这里我们直接用上面在
push_back()接口中所写的即可
// 1.首先考虑扩容逻辑
if (_finish == _end_of_storage)
{
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
}
以下是整体的代码
void insert(iterator pos, const T& x)
{
assert(pos >= _start && pos <= _finish);
// 1.首先考虑扩容逻辑
if (_finish == _end_of_storage)
{
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
}
// 2.挪动数据
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
}
- 那么对于
push_back()这个接口我们就可以去复用一下【insert】这个接口了
void push_back(const T& x)
{
/*if (_finish == _end_of_storage)
{
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
}
*_finish = x;
_finish++;*/
insert(end(), x);
}
💻第三轮测试 — 迭代器失效问题
- 好，在写完【insert】接口后，我们再来做一个测试。可以发现程序崩溃了
马上，我们通过调试来观察一下
- 此时我们已经往【v】中插入了4个数据，马上使用
insert(v.begin(), 100)去做一个头插，那么一进到函数中我们就可以知道这个当前对象的_start和pos所处的迭代器位置是相同的，也就是同一段空间的地址
- 那此时我们知道容器中的空间已经满了，所以会去走一个扩容的逻辑，此时可以看到当前对象this的
_start已经发生了改变
- 可以看到，在扩完容之后，当前对象的
_start和待插入位置的pos已经发生了变化，那么在此时我们再去挪动数据进行插入的时候就会出现问题了
💬 我们可以通过下面的图示来看看到底这个扩完容之后是怎样的
- 可以看到
_start确实发生了一个变化，但是呢pos还是指向原来的那个地方。那读者可以自己去想象一下子在遍历挪动数据的时候究竟何时才是个头呢？
- 我们可以通过调试再来观察一下挪动数据这段逻辑，可以看到在挪动完几次数据后就出现了随机值，并且出现了死循环的问题
🔰 以上所出现的这个问题就被称作是 【迭代器失效的问题】
那我们要如何去解决呢？
💬 有同学说，内部外部无法一起修改的话参数部分加个引用不就行了
void insert(iterator& pos, const T& x)
- 这其实是不对的，因为有些时候我们所传递的迭代器位置是
v.begin() + 3，在这中间会去产生一个临时对象，我们知道临时对象是具有常性的，那么传递进去的时候就会造成【权限放大】的问题
v.insert(v.begin() + 3, 6);
💬 那有同学又说，那防止一下权限放大不就好了，加个const
- 这肯定是不可以的，看到程序依旧会出现问题
- 首先大家要明白的一个点是出错的根本原因在于：
_start的位置改变了但是pos的位置没有发生改变。 - 所以我们所要做的一个点就是：让
pos的位置随着_start的变动而一起变动，这样就不会出现问题了。以下我们需要改进的代码部分，在进行扩容之前，我们可以先去计算一下从【_start】到【pos】的位置有多远； - 然后呢我们在执行完扩容的逻辑之后，就要去更新一下这个【pos】迭代器的位置所在，就使用刚才计算出来的这段距离即可
// 1.首先考虑扩容逻辑
if (_finish == _end_of_storage)
{
// 首先保存一下从_start到pos的距离
size_t len = pos - _start;
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
// 再扩完容之后更新一下pos, 解决迭代器失效问题
pos = _start + len;
}
那代码做了更新之后迭代器失效的问题真的解决了呢，我们通过调试一起来看看
- 可以看到，通过我们的骚操作😛【pos】位置就随着【start】的变化而随着变化
- 但是呢就上面这样还不够，我们只解决了内部迭代器失效的问题，而外部迭代器失效的问题并没有很好地解决。
- 外部迭代器，那是什么东西？ 我们来看下这段代码
bit::vector<int>::iterator it = v.begin();
v.insert(it, 33);
bit::print(v);
cout << *it << endl;
bit::print(v);
可以看到，在使用完这个这个迭代器之后再去访问就出现了问题
如果直接其换成库里面的【vector】的话，就直接崩溃了
👉 所以，对于迭代器这一块我们在使用的时候一定要慎重，在使用完之后不要去轻易地修改它
it = v.insert(it, 33);
- 如何执意要进行修改的话也不是没有办法，我们只需要在【insert】之后去接受一下当前所操作的这个迭代器的位置即可，记住这个位置，下次在访问的时候也就不会出问题
具体代码如下：
iterator insert(iterator pos, const T& x)
{
assert(pos >= _start && pos <= _finish);
// 1.首先考虑扩容逻辑
if (_finish == _end_of_storage)
{
// 首先保存一下从_start到pos的距离
size_t len = pos - _start;
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
// 再扩完容之后更新一下pos, 解决迭代器失效问题
pos = _start + len;
}
// 2.挪动数据
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
return pos;
}
有【insert】，那一定少不了【erase】，我们继续来看看
- 对于【erase】来说，我们也是需要先去挪动数据的，但是在这里呢我们需要从前往后挪，也是防止造成覆盖的情况
具体代码如下：
void erase(iterator pos)
{
assert(pos >= _start && pos < _finish);
iterator end = pos + 1;
// 移动覆盖
while (end != _finish)
{
*(end - 1) = *end;
++end;
}
--_finish;
}
立马来测试一下：
💬 对于【insert】来说会存在迭代器失效的问题，那对【erase】来说也会有吗？
- 我们立马通过下面的代码来测试一下
void test_vector8()
{
bit::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
bit::print(v);
auto it = v.begin();
v.erase(it);
cout << *it << endl;
it++;
cout << *it << endl;
bit::print(v);
}
- 运行起来我们可以看到，并没有出现任何的问题，首先去删除了第一个元素，然后再访问到首个位置便是【2】，接下去再去执行
it++并访问的话便是【3】
- 但若是我们将代码换成下面这样的话就会出现问题了
auto it = v.begin() + 3;
- 运行起来可以看到，当我们删除完最后一个元素后再让迭代器后移，就造成了访问越界的问题，出现了随机值的情况
不过呢，上面只是我们使用自己模拟的【vector】，来用用库里的会看会发生什么情况
- 但是呢我们可以看到如果使用库里面的话就会直接造成程序崩溃的问题
💬 上面呢是在VS下的运行结果，之前有说过VS在的STL是【PJ版】，而Linux下则是【SGI版】，所以我们都要去做一个对比
- 可以看到，神奇的事情发生了~ 在Linux下执行同样的两段代码，却没有发生像VS里面那样的报错，甚至在访问越界之后也没有出现随机值的问题，而是【0】
【小结】：
erase以后，迭代器失效了，不能访问。VS进行强制，访问会直接报错；Linux下则不会
然后我们再来看一个点
- 下面这个场景是通过迭代器的形式去删除其中的偶数
auto it = v.begin();
while(it != v.end())
{
if(*it % 2 == 0)
{
v.erase(it);
}
++it;
}
通过运行结果我们可以看出，确实所有的偶数都被删除了
换一个测试用例，我们加一个【2】，然后在删除的时候就发现【2】没有被删干净
再换一个测试用例，我在最后加了一个【6】，运行之后发现报出了Segmentation fault，这是Linux下的段错误问题
我们通过画图来分析一下
- 首先是对于第二种，根据代码来进行走读，当我们删除了第一个【2】后，后面的四个元素就往前移动了一个位置，接着迭代器++后移，就来到了【3】的位置，所以就错过了第2个【2】
- 那对于第三种测试案例，因为最后一个是 偶数 的原因，所以在删除之后迭代器进行了后移，此时呢它已经是越过了
end()的位置，再去判断的话永远都到不了，所以就出现了【Segmentation fault】的问题
💬 那要如何去避免呢？
- 这其实很简单，我们不要让这个迭代器每次都后移就可以了
auto it = v.begin();
while(it != v.end())
{
if(*it % 2 == 0)
{
v.erase(it);
}
else
{
++it;
}
}
再去打印看一下看看就发现没什么问题了
- 但是呢这段代码如果放到VS上去的话就不一样了，在Linux下确实是不会出现什么问题，但是在VS下还是一样会直接报错，因为VS会进行强制检查，在访问了一次迭代器之后就不可以再继续访问了
💬 此时我们需要去考虑一下【erase】这个接口的详情了
- 我们要看的是这个返回值，其返回值是一个迭代器，而且是刚刚被删除那个元素的下一个位置
iterator erase (const_iterator position);
- 那如果是这样的话我们就可以考虑在每次删除完一个位置的数据后拿返回值接收一下这个所删除元素的下一个位置，那么在下一次继续访问的时候就不会造成修改操作的问题了
it = v.erase(it);
最后【erase】接口的整体代码如下所示：
iterator erase(iterator pos)
{
assert(pos >= _start && pos < _finish);
iterator end = pos + 1;
// 移动覆盖
while (end != _finish)
{
*(end - 1) = *end;
++end;
}
--_finish;
return pos;
}
在有了【erase】之后，我们就可以让
pop_back()去复用这个接口了，可以达到尾删的逻辑
void pop_back()
{
// 复用erase
erase(end() - 1);
}
- 最后的话再来讲讲【swap】这个接口，很简单，就是去调用库里面的这个模版函数
swap，去一一交换两个对象中的三个成员变量即可。这个接口我下面在讲【赋值重载】时会使用到
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_of_storage, v._end_of_storage);
}
5、默认成员函数
讲了这么多，终于能来讲讲默认的成员函数了
- 首先的话一定是构造函数，有参构造是一定要实现的，因为这里的逻辑和
resize()是类似的，因此我们直接去做一个复用即可
// 有参构造
vector(size_t n, const T& val = T())
{
resize(n, val);
}
- 那我们在构造的时候就可以去做一个初始化了，发现和
v.resize(10, 0)是同样的效果
bit::vector<int> v(10, 0);
💬 那有同学可能会问，三个私有成员变量不需要去做初始化吗？
- 同学，难道你忘了我们在一开始的时候已经给到了它们初始值为
nullptr吗？这个措施就是很好地避免编译器对内置类型不会去做初始化的问题
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _end_of_storage = nullptr;
- 除了上面这种初始化，我再介绍一种方法：那就是使用 迭代器区间
- 这里我们可以去使用循环配合【push_back】接口去做一个初始化
// [first, last)
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
💻第四轮测试 — 双重构造引发调用歧义
接下去，我们马上对这个迭代器区间做的初始化操作去所一个测试
void test_vector6()
{
bit::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
bit::vector<int> v2(v.begin(), v.end());
string s("abcdef");
bit::vector<int> v2(s.begin(), s.end());
int a[] = { 1,2,3,4 };
bit::vector<int> v2(a, a + 4);
}
可以看到，除了去初始化自己【vector】对象的迭代器区间，【string】对象也可以，而且指针也没问题
💬 但此时呢，如果我再去以下面的有参构造进行初始化的话就会出现一些问题
bit::vector<int> v5(10, 1);
可以看到，说是“非法的间接寻址”
- 这里对迭代器
first去进行解引用目的就是为了获取这个位置上的数据，我们在 指针一文 有所提到 只有指针和迭代器可以解引用，基本数据类型不能解引用
💬 但是有同学一定会疑惑说：为什么这里不会去匹配有参构造，而是去匹配的迭代器区间构造呢？
- 在讲 C++模版 的时候，我们有说到过模版参数会去进行自动类型推导，从而匹配最合适函数模版。因为我们在这里所传入的【10】和【1】都是
int类型，但是呢有参构造的第一个形参类型为size_t，并不是最匹配的 - 而迭代器区间初始化其参数类型都是模版参数，所以在匹配的时候它是最优先进行匹配的
那我们该如何去进行预防呢？
- 很简单，我们可以利用在 C++重载函数 中所学习的参数类型不同去另写一个有参构造的重载形式
vector(size_t n, const T& val = T())
{
resize(n, val);
}
vector(int n, const T& val = T())
{
resize(n, val);
}
通过调试我们可以看出这里在调用的时候就没有歧义了
💬 最后再补充一个小的知识点，作为拓展
- 那我们在写了这个重载函数后要如何去调用对应的无符号类型
size_t呢，此时我们只需要在传递的参数后加上一个u即可，那么编译器在进行识别的时候就会自动将其识别成为无符号整数
bit::vector<int> v6(10u, 6);
一样通过调试来看就可以很清楚
讲完构造函数了，我们来看看拷贝构造
- 首先读者要明确为什么要写拷贝构造，这个我们通过调试来看一下就知道了：很明显可以看到这里只是做了一个浅拷贝，而不是去做了深拷贝
- 所以我们要自己去实现一个深拷贝，逻辑很简单，就不赘述
// 拷贝构造
vector(vector<int>& v)
{
_start = new T[v.capacity()];
memcpy(tmp, v._start, sizeof(T) * v.size());
_finish = tmp + v.size();
_end_of_storage = tmp + v.capacity();
}
- 但是看到上面这个
memcpy()，你是否会有一种警惕的心理呢，因为我们上面讲到过 vector 对象中存放的是 string数组，在拷贝的过程中会产生浅拷贝的问题，那就不可以去使用这个memcpy()，具体问题间下图
- 所以拷贝构造的正确形式应该是下面这样的
// 拷贝构造
vector(vector<T>& v)
{
_start = new T[v.capacity()];
//memcpy(_start, v._start, sizeof(T) * v.size());
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
_finish = _start + v.size();
_end_of_storage = _start + v.capacity();
}
- 可以看到，在改成深拷贝后就不会出现类似的问题了
- 当然我们也可以去做一个投机取巧，复用当前已经实现过的接口【reserve】和【push_back】，首先根据所传递进来对象的容量去做一个扩容的逻辑，开出足够多的空间后再将这个对象中的数据一一尾插进当前对象即可
vector(vector<int>& v)
{
// 根据v的capacity()去开出对应的空间
reserve(v.capacity());
for (size_t i = 0; i < v.size(); i++)
{
push_back(v[i]);
}
}
有了拷贝构造，【赋值重载】也少不了
- 还记得我们在上面所实现过的【swap】接口吗，在进行 string模拟 的时候，我们又使用到这么一个巧计，那就是使用 传值传参，首先会去调用一个拷贝构造构造一个临时对象，但是临时对象出了作用域之后肯定是要销毁的
- 此时我们就可以使用【swap】和当前对象去做一个交换，我呢获取到了你里面的内容，你帮我释放了不需要的内容，简直一举两得（还记得PUA弟弟的故事吗😆）
// 赋值重载
const vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
- 好，我们来调试观察一下。看到在调用赋值重载前就会去 调用拷贝构造
最后的舞台，给到【析构函数】，再怎么花里胡哨，最后最后空间都是要还给操作系统的
~vector()
{
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
OK，以上就是有关vector深度剖析及模拟实现，希望对您有帮助🌹
