C++ STL中 vector 的模拟实现

一、前言

在C++的STL中，vector 是一个顺序容器，代表一个可动态增长的数组。因此，自己在进行模拟实现时，跟写动态顺序表类似。

需要注意的是，vector 是一个类模板。

推荐的 C/C++ 参考文档：http://www.cplusplus.com

二、模拟实现的意义何在？

为了更好地理解 vector 的底层实现原理，加深对 vector 的认知。

三、vector 的模拟实现

首先，先定义 vector 。为了防止命名冲突，将它放在一个叫做 MyLib 的命名空间里。

模拟实现 vector 时，vector 类模板的框架参考 SGI 的 STL3.0 版本的源码。

namespace MyLib
{
	template<class T>
	class vector
	{
	public:
		//迭代器
		typedef T* iterator;
		typedef const T* const_iterator;
		
		//成员函数
	
	private:
		iterator _start;  // 指向数据块的起始位置
		iterator _finish;  // 指向有效元素的尾
		iterator _endofstorage;  // 指向存储容量的尾
	};
}

图解 vector：

下面模拟实现的都是一些比较常用的重载函数。

成员函数：

0.迭代器相关函数

调用库里的话，一般这么写：

vector<int> v1;
for (size_t i = 0; i < 10; ++i)
{
	v1.push_back(i);
}

//遍历
vector<int>::iterator it = v1.begin();
while (it != v1.end())
{
	cout << *it << " ";
	++it;
}
cout << endl;

begin 函数

作用是返回 vector对象内部的指向数据块起始位置的迭代器。

//普通版本
iterator begin()
{
	return _start;
}

//const版本
const_iterator begin() const
{
	return _start;
}

end 函数

作用是返回 vector对象内部的指向有效元素的尾的迭代器。

//普通版本
iterator end()
{
	return _finish;
}

//const版本
const_iterator end() const
{
	return _finish;
}

1.构造函数

在定义一个 vector 对象时，调用库里的话，一般这么写：

//将 vector 初始化为空
vector<int> v1;

或

//使用迭代器区间去初始化 vector
vector<string> v3(v2.begin(), v2.end());  // v2的类型是 vector<string>
或
vector<int> v5(v4.begin(), v4.end());  // v4的类型是 vector<int>

作用是构造一个 vector对象。

下面模拟实现构造函数的两个重载函数。

//将 vector 初始化为空
vector()
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstorage(nullptr)
{}

//使用迭代器区间去初始化 vector
template<class InputIterator>
vector(InputIterator first, InputIterator last)  
	:_start(nullptr)         // 先初始化私有成员变量，避免野指针
	,_finish(nullptr)
	,_endofstorage(nullptr)
{
	while (first != last)
	{
		push_back(*first);  // 复用模拟实现的函数 push_back
		++first;
	}
}

该函数既是一个类模板的成员函数，又是一个函数模板。

传入的迭代器区间可以是任意容器的迭代器区间。

2.析构函数

作用是在 vector对象销毁时释放内部的空间资源。

~vector()
{
	delete[] _start;
	_start = _finish = _endofstorage = nullptr;
}

3.拷贝构造函数

调用库里的话，一般这么写：

vector<int> v2(v1);

作用是将已有的对象拷贝一份，去初始化创建新的对象。

//传统写法
vector(const vector<T>& v)
{
	_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];  // 元素类型：对自定义类型和内置类型均可
	}  // 若是涉及空间资源管理的自定义类型，会调用赋值重载函数来实现深拷贝
}

为什么不能用 memcpy 去拷贝 vector的元素呢？
这又涉及深浅拷贝的问题了。
首先，memcpy 函数实现的是浅拷贝（值拷贝），并不是深拷贝。
1）如果元素类型是内置类型，是没问题的。
2）如果元素类型是自定义类型，并且该自定义类型涉及空间资源的管理，就不能用浅拷贝了，得用深拷贝。
因此，不能用 memcpy 去拷贝 vector的元素。

以下模拟实现的涉及拷贝的成员函数，都不用 memcpy 函数，都是因为上述原因。

//现代写法
vector(const vector<T>& v)
	:_start(nullptr)       // 先初始化私有成员变量，避免野指针
	,_finish(nullptr)
	,_endofstorage(nullptr)
{
	vector<T> tmp(v.begin(), v.end());  // 复用模拟实现的使用迭代器区间去初始化的构造函数
	
	swap(tmp);  // 复用模拟实现的函数 swap
}

4.赋值重载函数

调用库里的话，一般这么写：

vector<int> v2;
v2 = v1;

作用是将已有的对象赋值给另一个已有的对象。

//更简洁的现代写法
vector<T>& operator=(vector<T> v)  // 传值传参，调用拷贝构造函数
{
	swap(v);  // 复用模拟实现的函数 swap

	return *this;
}

其实，函数原型也可以省去模板参数：< T > ，写成 vector& operator=(vector v); ，其他的函数原型也可以这么写。

5. size 函数

调用库里的话，一般这么写：

for(size_t i = 0; i < v1.size(); ++i)
{
	//...
}

作用是返回 vector对象内部元素的个数。

size_t size() const
{
	return _finish - _start;
}

6. capacity 函数

调用库里的话，一般这么写：

cout << v1.capacity() << endl;

作用是返回 vector对象内部的容量。

size_t capacity() const
{
	return _endofstorage - _start;
}

图解 size函数 和 capacity函数：

7. swap 函数

调用库里的话，一般这么写：

v2.swap(v1);

作用是将两个对象的私有成员的值进行交换。

void swap(vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_endofstorage, v._endofstorage);
}

直接调用三次 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;

作用是返回 _start[ i ]的引用，即返回 vector对象内部元素的引用。

//普通版本（返回引用）
T& operator[](size_t i)
{
	assert(i < size());  // 防止访问越界
	
	return _start[i];
}

//const版本（返回常引用，无法修改）
const T& operator[](size_t i) const
{
	assert(i < size());  // 防止访问越界
	
	return _start[i];
}

9. reserve 函数

调用库里的话，一般这么写：

v1.reserve(50);

作用是扩容（将储存元素的空间容量扩大为 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;
	}
}

为什么不能用 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);

作用是改变 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;
		}
	}
}

如果没有实参传给 val ，val 就会使用缺省值：
1）如果缺省值是自定义类型，会调用默认构造函数去初始化匿名对象，再把匿名对象给 val 。
2）如果元素类型是内置类型，会使用内置类型的默认值（比如 int 类型的默认值是 0）给 val 。

int x = int();
这条语句是合法的，x 是 0 。

11. insert 函数

调用库里的话，一般这么写：

vector<int>::iterator ret = find(v1.begin(), v1.end(), 4);
if (ret != v1.end())  // 找到了
{
	v1.insert(ret, 7);
}

作用是在指定的位置处插入元素。

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;
}

关于迭代器失效的问题：

如果在插入元素前需要扩容，（由于扩容是开辟新空间并释放旧空间，）那么扩容后由于 pos 没有得到更新使得 pos 变成野指针，从而导致 pos 失效，此时再将新元素插入 pos 所指的位置是非法访问。
针对这个问题，解决方法也很简单，只需要在扩容后更新一下 pos 即可。

但由于该函数是传值传参，虽然函数里面的 pos 更新了，但外面的实参还没有更新，仍然是野指针，是失效的。
针对这个问题，STL 是通过返回新的迭代器来解决的。在模拟实现时，也设置返回值让外面的实参接收一下来更新实参。

STL 规定，调用 insert 函数后返回的迭代器是指向刚插进去的元素。
这里模拟实现的 insert 函数返回的迭代器是满足规定的。

12. erase 函数

调用库里的话，一般这么写：

vector<int>::iterator ret = find(v1.begin(), v1.end(), 8);
if (ret != v1.end())  // 找到了
{
	v1.erase(ret);
}

作用是删除某个特定的元素。

iterator erase(iterator pos)
{
	//检查传进来的迭代器是否合法
	assert(pos >= _start);
	assert(pos < _finish);
	
	//往前挪动数据
	iterator begin = pos + 1;
	while (begin < _finish)
	{
		*(begin - 1) = *begin;
		++begin;
	}

	--_finish;

	return pos;
}

关于迭代器失效的问题：

如果使用 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<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);

作用是尾插一个元素。

void push_back(const T& val)
{
	//检查是否需要扩容
	if (_finish == _endofstorage)
	{
		reserve(capacity() == 0 ? 4 : capacity() * 2);
	}

	*_finish = val;
	++_finish;
}

14. pop_back 函数

调用库里的话，一般这么写：

vector<int> v1;
v1.push_back(2);
v1.push_back(4);
v1.push_back(6);
v1.pop_back();

作用是尾删一个元素。

void pop_back()
{
	assert(_finish > _start);  // 检查是否合法

	--_finish;
}

在 vector 的模拟实现中，还有一些细节上的东西，这些在之前写的一篇博客当中有所提及，这里不再重复，有需要的可自行点击查看：C++ STL中 string类的模拟实现