前言
本文将带你从零开始实现STL库中Vector，编写常用的Vector接口。通过复现Vector的功能，可以让你对顺序表的增删查改有更深入的理解，能更深入地体会C++的内存管理风格。文中还将介绍深拷贝的两种实现，传统写法以及现代写法。博主也是初学者，如果有表述不对的地方，还请大佬多多指教。
当然，在继续深入Vector，尝试实现它之前，一定先能熟练使用，并且对数据结构中顺序表的原理有一定的了解。
Vector的常用接口
Vector的本质是用动态数组实现的一个顺序表，所以想要实现Vector的基本功能，就需要有数据结构中顺序表的增删查改原理的基本知识。接下来，我会以Vector的常用接口为例，讲解顺序表的增删查改。如果觉得纯文字有些抽象，可以结合顺序表-数组 | 图码观看直观的增删查改的动图。
Push_back()
- 检查顺序表是否有足够的容量来容纳新插入的元素，如果没有，则需要扩容。
- 直接将数组末尾的值改为要插入的元素
- 将顺序表的size()加一
伪代码如下：
FUNCTION Push_back(element)
IF 容量<已有元素个数加插入元素个数
扩容
在顺序表的末尾插入element
增加顺序表的元素个数
return；
Insert()
- 先检查顺序表的容量，确定是否需要扩容。
- 将插入位置之后的n个元素向后移动(n为插入元素的数量），以为新元素腾出空间。
- 将新元素复制或移动到顺序表的对应位置。
伪代码如下：
FUNCTION Insert(sequence, index, element)
IF 插入位置index不合法
RETURN "插入位置无效"
IF 容量<已有元素个数加插入元素个数
扩容
FOR 从后向前移动元素，为新元素腾出空间
在index的位置处插入element
增加顺序表的元素个数
return；
Pop_back()
直接将顺序表的末尾标记向前移动，并将元素个数减一即可。因为再在顺序表的末尾插入的时候，就能将原数据覆盖，从而达到了尾删的效果。
Erase()
相对Pop_back()较难一些，因为涉及到数据的挪动，需要注意下标与顺序表的实际范围。
伪代码如下：
FUNCTION Erase(sequence, index)
IF 删除位置index不合法
RETURN "删除位置无效"
FOR 从删除位置开始，向前移动元素
减小顺序表的长度
Vector的模拟实现
本文只实现最最常用的Vector接口，如果有其他接口想要实现，可以参考下面这个链接：
由于目标是实现Vector，所以一下接口实际是Vector类的成员函数，但是为了方便博客，从而分开为独立的函数。
成员函数及迭代器
我们使用三个成员函数实现Vector,是，三个指针分别标识顺序表的头，数据的尾以及内存的尾。
private:
T* _start = nullptr;
T* _end = nullptr;
T* _storage_end = nullptr;
因此，奠定了Vector的本质是一个数组，所以迭代器的实现也很简单，直接封装指针即可：
typedef T* iterator;
typedef const T* const_iterator;
Vector的构造函数及析构函数
指针作为内置类型，不需要专门写构造函数，但是可以使用C++11标准的前置构造声明，让编译器调用用默认的构造函数。
vector() = default;
其他构造均可以利用push_back()接口实现：通过遍历原Vector，将原Vector的元素依次插入新的Vector：
vector(const vector<T>& v) {
reserve(v.size());
for (auto& e : v) {
push_back(e);
}
}
template<class InputIterator>
vector(InputIterator start, InputIterator end) {
reserve(end - start);
while (start != end) {
push_back(*start);
start++;
}
}
vector(size_t n, const T& val = T()) {
reserve(n);
int cot = n;
while (n--) {
push_back(T);
}
}
vector(int n, const T& val = T()) {
reserve(n);
int cot = n;
while (n--) {
push_back(val);
}
}
析构函数先释放内存，然后将三个指针置空：
~vector() {
if (_start)
{
delete[] _start;
_start = _end = _storage_end = nullptr;
}
}
“增”（Create）
增主要涉及的接口就是push_back()及insert(),实现思路与顺序表原理一致，直接上代码：
void push_back(const T& x) {
if (_end == _storage_end)
//检查顺序表的容量，如果为空，初始化为4
//否则，执行二倍扩容
reserve(capacity() == 0 ? 4 : capacity() * 2);
*_end = x;
_end++;
}
iterator insert(iterator pos, const T& x) {
assert(pos >= _start);
assert(pos <= _end);
size_t positon = pos - _start;
if (size() == capacity()) {
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + positon;
}
iterator cur = _end;
while (cur > pos) {
*cur = *(cur - 1);
--cur;
}
*cur = x;
_end++;
return pos;
}
iterator insert(iterator pos, size_t n, const T& x) {
int position = pos - _start;
if (size() + n < capacity()) {
reserve(capacity() == 0 ? n : capacity() * 2);
pos = _start + position;
}
_end += n;
iterator cur = _end - 1;
while (cur >= pos + n) {
*cur = *(cur - n);
cur--;
}
while (cur >= pos) {
*cur = x;
--cur;
}
return pos;
}
“删”（Delete）
如果上面的能搞定，那么“删”更是不在话下了，小菜一叠：）
void pop_back() {
assert(!empty());
--_end;
}
iterator erase(iterator pos) {
iterator it = pos;
while (it != end()) {
*it = *(it + 1);
it++;
}
--_end;
return pos;
}
iterator erase(iterator head, iterator tail) {
size_t change = tail - head;
iterator it_pre = head;
iterator it_cur = tail;
while (it_cur != end()) {
*it_pre = *it_cur;
++it_pre;
++it_cur;
}
_end-=change;
return head;
}
“查”（Read）
查操作涉及对顺序表属性的获取，如存储的元素，顺序表容量等等。由于Vector底层是数组的先天优势，为了获得这些属性，往往只需要对成员变量进行加减运算即可，直接看代码也能理解背后的意思。
//_end指向顺序表最后一个元素的下一个位置(隐含+1)
//_start指向顺序表的第一个元素，所以直接相减记得元素个数
//一定要对this加const
size_t size() const{
return _end - _start;
}
size_t capacity() const{
return _storage_end - _start;
}
//Vector的底层是数组，所以直接运算符重载就能模拟数组行为
T& operator[](size_t pos) {
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const {
assert(pos < size());
return _start[pos];
}
iterator begin() {
return _start;
}
//end()为顺序表的最后一个元素的下一个位置
iterator end() {
return _end;
}
const_iterator begin() const{
return _start;
}
const_iterator end() const {
return _end;
}
//由于_end指向顺序表最后一个元素的下一个位置，
//所以当头尾指针重合即代表没有元素，顺序表为空
bool empty() {
return _end == _start;
}
“改”（Update）
改是Vector实现的重头戏。如果细心阅读了上面的代码，一定会发现，我们在做增删查的操作的时候，其实都没有涉及底层的数组的初始化，这一切其实都是在reserve()中完成的。reserve()不仅肩负着Vector的初始化，还涉及了元素的深拷贝，任务繁重。详细的代码解读见注释。
void reserve(size_t n) {
//不进行缩小容量的操作
if (capacity() < n) {
size_t old_size = size();
T* temp = new T[n];
//要进行深拷贝，不能直接用memcpy
//赋值构造中就隐藏了深拷贝的实现
for (size_t i = 0; i < old_size; i++) {
temp[i] = _start[i];
}
delete[] _start;//new时有[],delete时一定要对应使用
//同时还可以做到指针初始化的作用
_start = temp;
_end = temp + old_size;
_storage_end = temp + n;
}
}
resize()也可以偷懒的使用push_back()进行实现，因为如果不考虑顺序表大小减小的操作，其本质上其实也是重复的尾插数据。
void resize(size_t n, vector<T>& e = T()) {
if (n > size()) {
reserve(n);
int cot = n - size();
while (cot--) {
push_back(e);
}
}
}
深拷贝的传统与现代
我认为这个小节是这篇博客最精华的地方，带你详细搞懂深拷贝的前世今生。
在较老的C++标准中，如 C++98/03 标准中，实现深拷贝通常需要手动编写拷贝构造函数和拷贝赋值运算符。以Vector为例，当我们实现赋值运算符重载时，传统写法要求你手动对底层的每一个数据进行拷贝，这种方法是直接而明确的，但往往考虑的细节就比较多。
- 检查不能对自己进行赋值。
- 申请开辟一片与右值大小一致的空间。
- 对右值的每一个元素深拷贝，即需调用其构造函数。
- 然后处理this的成员变量。
vector<T>& operator=(vector<T>& v) {
if (this != &v) {
clear();
_start = new T[v.size()];
for (int i = 0;i<v.size();i++) {
_start[i] =*(new T(v[i]));
}
_end = _start + v.size();
_storage_end = _start + v.capacity();
}
return *this;
}
void clear() {
_end = _start;
}
随着C++的标准更新，便有了新的深拷贝写法。现代写法真正释放了程序员双手，实现自动化深拷贝。在现代写法中，拷贝构造函数使用了初始化列表等直接初始化成员，这是更高效的做法。写一次拷贝构造函数，此后就能一劳永逸了。
vector<T>& operator= (vector<T>& v) {
if (this != &v) {
vector<T> temp(v);
swap(temp);
}
return *this;
}
void swap(vector<T>& v) {
std::swap(_start, v._start);
std::swap(_end, v._end);
std::swap(_storage_end, v._storage_end);
}
谢谢你的阅读，各位程序员1024节快乐！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
