C++ STL中 vector 的模拟实现
一、前言
二、模拟实现的意义何在？
三、vector 的模拟实现
成员函数：
0.迭代器相关函数
begin 函数
end 函数
1.构造函数
2.析构函数
3.拷贝构造函数
4.赋值重载函数
5. size 函数
6. capacity 函数
7. swap 函数
8. operator[] 函数
9. reserve 函数
10. resize 函数
11. insert 函数
12. erase 函数
（迭代器失效）
13. push_back 函数
14. pop_back 函数
一、前言
在C++的STL中，vector 是一个顺序容器，代表一个可动态增长的数组。因此，自己在进行模拟实现时，跟写动态顺序表类似。
需要注意的是，vector 是一个类模板。
推荐的 C/C++ 参考文档：http://www.cplusplus.com
二、模拟实现的意义何在？
为了更好地理解 vector 的底层实现原理，加深对 vector 的认知。
三、vector 的模拟实现
首先，先定义 vector 。为了防止命名冲突，将它放在一个叫做 MyLib 的命名空间里。
模拟实现 vector 时，vector 类模板的框架参考 SGI 的 STL3.0 版本的源码。
namespace MyLib
{
template
class vector
{
public:
//迭代器
typedef T* iterator;
typedef const T* const_iterator;
//成员函数
private:
iterator _start; // 指向数据块的起始位置
iterator _finish; // 指向有效元素的尾
iterator _endofstorage; // 指向存储容量的尾
};
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
图解 vector：
下面模拟实现的都是一些比较常用的重载函数。
成员函数：
0.迭代器相关函数
调用库里的话，一般这么写：
vector
for (size_t i = 0; i < 10; ++i)
{
v1.push_back(i);
}
//遍历
vector
while (it != v1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
begin 函数
作用是返回 vector对象内部的指向数据块起始位置的迭代器。
//普通版本
iterator begin()
{
return _start;
}
1
2
3
4
5
//const版本
const_iterator begin() const
{
return _start;
}
1
2
3
4
5
end 函数
作用是返回 vector对象内部的指向有效元素的尾的迭代器。
//普通版本
iterator end()
{
return _finish;
}
1
2
3
4
5
//const版本
const_iterator end() const
{
return _finish;
}
1
2
3
4
5
1.构造函数
在定义一个 vector 对象时，调用库里的话，一般这么写：
//将 vector 初始化为空
vector
或
//使用迭代器区间去初始化 vector
vector
或
vector
1
2
3
4
5
6
7
8
9
作用是构造一个 vector对象。
下面模拟实现构造函数的两个重载函数。
//将 vector 初始化为空
vector()
:_start(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{}
1
2
3
4
5
6
//使用迭代器区间去初始化 vector
template
vector(InputIterator first, InputIterator last)
:_start(nullptr) // 先初始化私有成员变量，避免野指针
,_finish(nullptr)
,_endofstorage(nullptr)
{
while (first != last)
{
push_back(*first); // 复用模拟实现的函数 push_back
++first;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
该函数既是一个类模板的成员函数，又是一个函数模板。
传入的迭代器区间可以是任意容器的迭代器区间。
2.析构函数
作用是在 vector对象销毁时释放内部的空间资源。
~vector()
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
1
2
3
4
5
3.拷贝构造函数
调用库里的话，一般这么写：
vector
1
作用是将已有的对象拷贝一份，去初始化创建新的对象。
//传统写法
vector(const vector
{
_start = new T[v.capacity()];
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
size_t sz = v.size();
//不能用 memcpy！
/*memcpy(_start, v._start, sizeof(T) * v.size());*/
for (size_t i = 0; i < sz; ++i)
{
_start[i] = v[i]; // 元素类型：对自定义类型和内置类型均可
} // 若是涉及空间资源管理的自定义类型，会调用赋值重载函数来实现深拷贝
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
为什么不能用 memcpy 去拷贝 vector的元素呢？
这又涉及深浅拷贝的问题了。
首先，memcpy 函数实现的是浅拷贝（值拷贝），并不是深拷贝。
1）如果元素类型是内置类型，是没问题的。
2）如果元素类型是自定义类型，并且该自定义类型涉及空间资源的管理，就不能用浅拷贝了，得用深拷贝。
因此，不能用 memcpy 去拷贝 vector的元素。
以下模拟实现的涉及拷贝的成员函数，都不用 memcpy 函数，都是因为上述原因。
//现代写法
vector(const vector
:_start(nullptr) // 先初始化私有成员变量，避免野指针
,_finish(nullptr)
,_endofstorage(nullptr)
{
vector
swap(tmp); // 复用模拟实现的函数 swap
}
1
2
3
4
5
6
7
8
9
10
4.赋值重载函数
调用库里的话，一般这么写：
vector
v2 = v1;
1
2
作用是将已有的对象赋值给另一个已有的对象。
//更简洁的现代写法
vector
{
swap(v); // 复用模拟实现的函数 swap
return *this;
}
1
2
3
4
5
6
7
其实，函数原型也可以省去模板参数：< T > ，写成 vector& operator=(vector v); ，其他的函数原型也可以这么写。
5. size 函数
调用库里的话，一般这么写：
for(size_t i = 0; i < v1.size(); ++i)
{
//...
}
1
2
3
4
作用是返回 vector对象内部元素的个数。
size_t size() const
{
return _finish - _start;
}
1
2
3
4
6. capacity 函数
调用库里的话，一般这么写：
cout << v1.capacity() << endl;
1
作用是返回 vector对象内部的容量。
size_t capacity() const
{
return _endofstorage - _start;
}
1
2
3
4
图解 size函数 和 capacity函数：
7. swap 函数
调用库里的话，一般这么写：
v2.swap(v1);
1
作用是将两个对象的私有成员的值进行交换。
void swap(vector
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
1
2
3
4
5
6
直接调用三次 std库里的 swap函数即可。
8. operator[] 函数
调用库里的话，一般这么写：
//修改
for(size_t i = 0; i < v1.size(); ++i)
{
v1[i] += 1;
}
//遍历
for(size_t i = 0; i < v1.size(); ++i)
{
cout << v1[i] << " ";
}
cout << endl;
1
2
3
4
5
6
7
8
9
10
11
12
作用是返回 _start[ i ]的引用，即返回 vector对象内部元素的引用。
//普通版本（返回引用）
T& operator[](size_t i)
{
assert(i < size()); // 防止访问越界
return _start[i];
}
1
2
3
4
5
6
7
//const版本（返回常引用，无法修改）
const T& operator[](size_t i) const
{
assert(i < size()); // 防止访问越界
return _start[i];
}
1
2
3
4
5
6
7
9. reserve 函数
调用库里的话，一般这么写：
v1.reserve(50);
1
作用是扩容（将储存元素的空间容量扩大为 n，其中 n 大于原来的空间容量）。
如果 n 小于或等于原来的空间容量，则什么都不干。
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = size(); // 小细节，在_start的指向改变前，要先把原来的size存起来
T* tmp = new T[n];
//不能用 memcpy！
/*memcpy(tmp, _start, sizeof(T) * size());*/
for (size_t i = 0; i < sz; ++i)
{
tmp[i] = _start[i]; // 元素类型：对自定义类型和内置类型均可
} // 若是涉及空间资源管理的自定义类型，会调用赋值重载函数来实现深拷贝
delete[] _start;
_start = tmp;
_finish = _start + sz;
_endofstorage = _start + n;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
为什么不能用 memcpy 函数，而是用 for 循环一个一个拷贝呢？
因为 vector对象的元素类型有可能是涉及空间资源管理的自定义类型，而 memcpy 函数完成的拷贝是浅拷贝，而 for 循环完成的拷贝是深拷贝。
由于必须采用深拷贝，所以不能用 memcpy 函数，而是用 for 循环一个一个拷贝。
比如，现在有一个 vector对象，它的元素类型是 string 。
如果用 memcpy 函数去拷贝，扩容完成后是这样的：
memcpy 函数直接把私有成员变量的值拷贝过来了，这就导致新空间的指针和旧空间的指针都指向了同一块空间资源（而且新空间的指针还丢失了原来所指的空间资源，造成内存泄漏），然后 delete 掉原空间，（由于 string 是自定义类型）会先调用 string 的析构函数释放该空间资源，但这就导致新空间的指针就变成了野指针，如果再对该空间资源进行访问，是违法的。或者当 vector对象被销毁时，新空间被 delete 掉，先调用 string 的析构函数，再一次对该空间资源进行释放。由于该空间资源被释放多次，就会导致程序崩溃。
因此，不能用 memcpy 函数去拷贝，应该用 for 循环。
扩容完成后应该是这样的：
那为什么 for 循环完成的是深拷贝呢？
因为 for 循环内有赋值语句，如果元素类型是涉及空间资源管理的自定义类型，则会调用赋值重载函数来实现深拷贝。
10. resize 函数
调用库里的话，一般这么写：
v1.resize(20);
或
v2.resize(25, 10);
1
2
3
作用是改变 vector对象内部的元素个数 。
1）若 n 小于或等于原来的元素个数，将元素个数保留为 n 个（不影响空间容量）。
2）若 n 大于原来的元素个数（若 n 大于原来的空间容量，就会先调用 reserve 函数进行扩容），将元素个数重新设置成 n 个，并用 val 填充多出来的空间。（给 val 设置缺省值）
void resize(size_t n, const T& val = T())
{
if (n <= size())
{
_finish = _start + n;
}
else
{
//检查是否需要扩容
if (n > capacity())
{
reserve(n);
}
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
如果没有实参传给 val ，val 就会使用缺省值：
1）如果缺省值是自定义类型，会调用默认构造函数去初始化匿名对象，再把匿名对象给 val 。
2）如果元素类型是内置类型，会使用内置类型的默认值（比如 int 类型的默认值是 0）给 val 。
int x = int();
这条语句是合法的，x 是 0 。
11. insert 函数
调用库里的话，一般这么写：
vector
if (ret != v1.end()) // 找到了
{
v1.insert(ret, 7);
}
1
2
3
4
5
作用是在指定的位置处插入元素。
iterator insert(iterator pos, const T& val)
{
//检查传进来的迭代器是否合法
assert(pos >= _start);
assert(pos <= _finish);
//检查是否需要扩容
if (_finish == _endofstorage)
{
size_t len = pos - _start; // 记录 pos 与 _start 的相对长度
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + len; // 由于扩容后会导致pos失效，需要在这里更新一下pos
}
//往后挪动数据
iterator end = _finish;
while (end > pos)
{
*end = *(end - 1);
--end;
}
//插入新元素
*pos = val;
++_finish;
return pos;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
关于迭代器失效的问题：
如果在插入元素前需要扩容，（由于扩容是开辟新空间并释放旧空间，）那么扩容后由于 pos 没有得到更新使得 pos 变成野指针，从而导致 pos 失效，此时再将新元素插入 pos 所指的位置是非法访问。
针对这个问题，解决方法也很简单，只需要在扩容后更新一下 pos 即可。
但由于该函数是传值传参，虽然函数里面的 pos 更新了，但外面的实参还没有更新，仍然是野指针，是失效的。
针对这个问题，STL 是通过返回新的迭代器来解决的。在模拟实现时，也设置返回值让外面的实参接收一下来更新实参。
STL 规定，调用 insert 函数后返回的迭代器是指向刚插进去的元素。
这里模拟实现的 insert 函数返回的迭代器是满足规定的。
12. erase 函数
调用库里的话，一般这么写：
vector
if (ret != v1.end()) // 找到了
{
v1.erase(ret);
}
1
2
3
4
5
作用是删除某个特定的元素。
iterator erase(iterator pos)
{
//检查传进来的迭代器是否合法
assert(pos >= _start);
assert(pos < _finish);
//往前挪动数据
iterator begin = pos + 1;
while (begin < _finish)
{
*(begin - 1) = *begin;
++begin;
}
--_finish;
return pos;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
关于迭代器失效的问题：
如果使用 erase 函数进行尾删，pos 此时指向的是最后一个元素。调用 erase 函数后，尾删成功了，不过这时 pos 指向的位置跟 _finish 指向的位置重合，pos 变成非法的了，即 pos 失效。若再次使用，会导致程序崩溃。
除了上面这种情况之外，某些版本实现的 erase 函数在删除元素后会进行缩容，从而导致迭代器失效（跟 insert 函数类似，都是由于发生空间的变更，在 pos 没有更新的情况下使得 pos 变为野指针，从而导致 pos 失效），解决方法跟 insert 函数一样，都是更新 pos，并设置返回值让外面的实参接收一下来更新实参。
STL 规定，调用 erase 函数后返回的迭代器是指向被删元素的下一个元素。
这里模拟实现的 erase 函数返回的迭代器是满足规定的，因为被删元素的下一个元素向前挪动后，恰好在原来的迭代器所指向的位置。
（迭代器失效）
不论什么容器，只要存在相关接口涉及迭代器的访问，都可能会使迭代器失效。
因为我们经常使用 insert接口 和 erase接口，所以迭代器失效在这两个接口体现得比较多。
用了 insert 函数和 erase 函数后，原有的迭代器可能失效，不建议再用了。非要再用的话，要接收函数返回值来更新一下旧的迭代器，或者再定义另一个迭代器。
13. push_back 函数
调用库里的话，一般这么写：
vector
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
1
2
3
4
作用是尾插一个元素。
void push_back(const T& val)
{
//检查是否需要扩容
if (_finish == _endofstorage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*_finish = val;
++_finish;
}
1
2
3
4
5
6
7
8
9
10
11
14. pop_back 函数
调用库里的话，一般这么写：
vector
v1.push_back(2);
v1.push_back(4);
v1.push_back(6);
v1.pop_back();
1
2
3
4
5
作用是尾删一个元素。
void pop_back()
{
assert(_finish > _start); // 检查是否合法
--_finish;
}
1
2
3
4
5
6
在 vector 的模拟实现中，还有一些细节上的东西，这些在之前写的一篇博客当中有所提及，这里不再重复，有需要的可自行点击查看：C++ STL中 string类的模拟实现
————————————————
版权声明：本文为CSDN博主「Butayarou」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_59938453/article/details/123598966