vector 的核心成员函数及其模拟实现

        在 C++ 的 STL 标准模板库中，vector无疑是我们最常用、也最熟悉的容器之一。它提供了动态数组的功能，让我们能够轻松地管理一系列数据。我们每天都在熟练地使用push_back() 等成员函数，但你是否好奇过这些便捷的功能在底层是如何实现的呢？

        本篇博客将带你深入 vector 的内部世界，不仅详细解析其常用成员函数的用法，更重要的是，我们将亲手模拟实现这些函数，从零开始构建一个属于我们自己的简易my_vector 类。这不仅能加深你对 STL 设计的理解，更能显著提升你的 C++ 内存管理能力和编程功底。

1. 简介

        vector算是C++的 STL 中最常用，也是最重要的容器之一了。我们可以把vector看做是一个动态增长的数组。而这个数组可以存储任意类型的变量。

        动态增长的意思就是，当我们尝试向一个已经满的vector数组中插入新的元素的时候，它会自动进行一个扩容的过程。这个过程不需要我们来实现，我们也不需要管它。

        此外，vector 最大的优点莫过于它重载了 “ [ ] ” ，使我们可以像数组一样随机存取它的任意一个值，时间复杂度为O(1)。

2. 核心成员函数及其实现

        在实现核心函数之前，要记得把自己实现的my_vector 类放在一个单独的命名空间中，这样在同一个命名空间下调用的函数就是我们自己实现的函数了。

2.1 成员变量

        C++ 的 STL 中实现的 vector 的成员函数其实并不是常规的一个指向数组的指针，一个容量和一个大小的。因为 vector 要存储的是各种各样的成员。所以STL中实现的vector是由三个迭代器实现的，分别是_start 、_finish、  _end_of_storage 这三个迭代器，其中_start 指向vector的第一个元素的位置。_finish 指向最后一个元素的下一个位置，大部分的STL的迭代器都是这样一个左闭右开的方式。_end_of_storage 则是指向开辟空间的最后的位置。

2.2 迭代器

2.2.1 迭代器的创建

        那么我们在实现核心成员函数之前，应该先是实现这些迭代器。迭代器我们可以把它们理解为指针。所以我们要定义迭代器只需要对类型指针 typedef 一下就可以了。除了普通的迭代器，我们还要记得给 const迭代器 typedef 一下。

       我们把我们自己的vector类放在自己新建的命名空间内，然后对类类型的指针进行typedef就可以了。我们这里给到成员变量缺省值，一会的默认构造函数就可以让编译器自己进行了。

namespace my_vector
{
    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;
    };
}

2.2.2 关于迭代器的函数

2.2.2.1 begin 和 end

        关于迭代器的最简单的函数莫过于这两个函数了，他们只需要返回头迭代器或尾迭代器的位置就可以了。我们的成员变量就是用迭代器构造的，这使得这两个函数更简单了。

        我们在实现普通迭代器版本的时候不要忘记顺序也实现一下 const 的版本。

iterator begin()
{
	return _start;
}

iterator end()
{
	return _finish;
}

const_iterator begin() const
{
    return _start;
}

const_iterator end() const
{
    return _finish;
}

2.2.2.2 size 和 capacity

        这两个函数在我们以往的类中，因为我们的成员变量中含有这两个值，所以我们可以直接返回。但是这次我们是使用的迭代器创建的成员变量。所以我们要用迭代器来计算这两个值。

        _finish - _start 我们就可以得到 size() 的大小了。我们以前学过，迭代器相减得到的数是它们相差的距离。由于这里是左闭右开，所以我命不需要做多余的操作。

        同理，我们要得到capacity() 只需要用_end_of_storage - _ start 就可以了。

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

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

2.2.2.3 empty

        这个函数也很好实现，如果_start 和 _finish的位置一样说明这个 vector 中根本没有元素存在，所以我们只需要判断_start 和_finish 的位置就可以了。

bool empty() const
{
	return _start == _finish;
}

2.3 默认成员函数

2.3.1 默认构造函数

        我们这里的成员变量其实只需要让编译器自己来生成构造函数就可以了，但是由于我们后面要实现拷贝构造函数，如果我们自己不实现默认构造函数的话就不会生成默认构造了。所以这里我们还需要自己实现一下默认构造。由于我们又给了缺省值，所以构造函数也很简单，只需要一行代码：

vector() = default; 

        这个 default 是C++11新加的功能，这样写编译器就还会自己再生成一个默认构造，就省的我们再去写了，既然我们已经在成员变量处给了缺省值就没有必要自己再手写一个默认构造了，让编译器写简单又快捷。

2.3.2 析构函数

        我们只需要在析构之前判断_start 是否为一个有效的指针就可以了。

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

2.3.3 拷贝构造函数

        既然是我们要一个数组中的所有元素，那么最好的方法就是遍历一遍原数组，然后一个个插入进去。拷贝构造函数的想法也是如此。

        我们只需要提前开辟一个和原数组一样大的空间，然后一个个遍历进去再插入就可以了。

vector(const vector<T>& v)
{
	reserve(v.size());   //扩容函数 我们后面实现
	for (auto& e : v)
	{
		push_back(e);    //尾插函数 同样后面实现
	}
}

2.3.4 赋值重载

        我们在实现赋值重载的时候依旧是使用新的方法，也就是把形参拷贝构造出来的类和原来的类交换一下。

        这里原理是，我们在对函数传值传参的时候，函数会自动生成一份原来数组的拷贝，也就是这个函数中的 v ，v就相当于是被实例化出来和实参一样的东西。这时我们对他们进行交换，被赋值的就赋值上了，函数结束以后，v 会自己析构掉。

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

	return *this;
}

2.4 修改数组的函数

2.4.1 reserve

        这里我们先实现对数组扩容的 reserve 函数，和我们之前实现的多数扩容函数类似。都是先判断是否要扩容，如果需要扩容就开新空间，改变指针，再销毁原来的空间：

        但是这里我们会遇到一个迭代器失效的问题。

void reserve(size_t n)   // 错误代码
{
	if (n > capacity())
	{
		T* tmp = new T[n];
		memcpy(tmp, _start, size() * sizeof(T));
		delete[] _start;

		_start = tmp;
		_finish = _start + size();
		_end_of_storage = _start + n;
	}
}

        仔细看一下代码，看逻辑好像并没有什么问题，但是运行的话就会崩溃。原因是我们的size函数是要用 _finish - _start 。但是我们在更新以后，我们的_finish = _start + size(); 这句代码调用size 的时候，我们的 _start 是新的位置，但是_finish 却还在上一个位置。这里我们应该提前记录数组的大小，以免出现这种问题。

        此外如果我们的原数组中存储的是类似于 string 这样的类类型，我们用memcpy拷贝到新数组以后，在销毁原数组的时候，那些存储着以前的数据也会被销毁，就会导致新数组中什么都没有。为了防止这种情况发生，用for循环遍历一遍数组逐个加到新数组中是更好的办法。

void reserve(size_t n)  // 正确代码
{
	if (n > capacity())
	{
		size_t old_size = size();
		T* tmp = new T[n];
		for (size_t i = 0; i < old_size; i++)
		{
			tmp[i] = _start[i];
		}
		delete[] _start;

		_start = tmp;
		_finish = tmp + old_size;
		_end_of_storage = tmp + n;
	}
}

2.4.2 push_back 和 pop_back

        尾插的时候我们要记得先判断空间还够不够，不够的时候进行扩容。尾删的时候就直接让_finish-- 就可以了。

void push_back(const T& x)
{
	if (_finish == _end_of_storage)
	{
		//依旧是没有空间扩4个 有空间就二倍扩
        reserve(capacity() == 0 ? 4 : capacity() * 2);
	}

	*_finish = x;
	++_finish;
}

void pop_back()
{
    //空的时候不能删
	assert(!empty());
	--_finish;
}

2.4.3 重载 [ ] 

        我们之前提到可以用 [ ] 对vector进行随机存取，这里我们就要重载一下这个运算符。因为我们要对这个位置进行修改，所以应该要传递的是这个位置的引用。

T& operator[](size_t i)
{
    //返回前判断一下 i 的合法性
	assert(i < size());
	return _start[i];
}

const T& operator[](size_t i) const
{
	assert(i < size())
	return _start[i];
}

2.4.4 insert

        我们要在pos位置前加一个 x ，插入的时候要记得把pos位置及以后的数都先往后挪动一格。

iterator insert(iterator pos, const T& x)
{
	assert(pos >= _start);
	assert(pos <= _finish);
			// 扩容
	if (_finish == _end_of_storage)
	{
		size_t len = pos - _start;
		reserve(capacity() == 0 ? 4 : capacity() * 2);
		pos = _start + len;
	}

	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
	*pos = x;

	++_finish;

	return pos;
}

        在这里我们返回一个值其实是模拟STL中实现的，一般来说我们并不需要返回一个insert以后位置的值。但是由于vector是用迭代器实现的。我们给他传一个pos位置的迭代器，它在insert以后是会向后移动的，这就会导致我们想修改pos位置的值，实际上修改到了pos + 1 的位置。所以我们才会给一个返回值。但是建议还是不要在insert以后对相同的位置进行操作。

2.4.5 erase

        erase 也要记得在删除后把后面的数据向前移动。

void erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);
	iterator it = pos + 1;
	while (it != end())
	{
		*(it - 1) = *it;
		++it;
	}

	--_finish;
}