前言：

在C++标准库（STL）中，vector容器是最常见使用的动态数组。它结合了链表与数组的优点，提供了灵活的大小调整与高效的随机访问。本文将简单的对vector容器进行介绍并且对vector容器简单的模拟实现。

一、vector的文档介绍

 

二、模拟实现的简单准备工作

在模拟实现之前，我们需要明确我们想要实现的基本接口。

根据https://cplusplus.com/reference/vector/vector/cplusplus网站的信息我们可以知道，vector虽然相对于string简化很多，但仍然有许多的接口，既然是简单的模拟实现，我们只需要实现最基本，常用的接口就行了。

另外，由于stl库里自带系统的vector类模板，为了区分，我们可以在自己的命名空间内完成对vector模板代码的编写。

三、模拟实现

1、vector的类参数

根据vector文档可知，本质上vector功能的正常运行大多都离不开三个指针，分别是：_start,_finish,_endOfStorage。这三个指针分别指向vector的开头，实际存储数据的末尾后一位，以及开辟的空间大小末尾，通过类函数成员对这三个参数的使用，来实现了不同的功能。

于是我们首先要定义的就是vector类模板的成员参数，注意，应该在private：下定义。

namespace MyVector
{
	template<class T>
	class vector
	{
	private:
		T* _start;
		T* _finish;
		T* _endOfStorage;
	};
}

2、类的迭代器

我们通过对vector源代码的剖析，发现，vector迭代器实际上是一个指针，于是我们可以用typedef重命名来定义我们vector的迭代器，并且为了美观，我们顺便把类的参数类型也修改为迭代器iterator。

注意，迭代器有两种类型，一种是可以修改参数的，另外一种是不能修改参数的“常量”迭代器。定义我们应该重命名两个迭代器。

namespace MyVector
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;

		typedef const T* const_iterater;
	private:
		iterator _start;
		iterator _finish;
		iterator _endOfStorage;
	};
}

3、begin(),end()的实现

有了迭代器，自然会产生操控迭代器位置的一系列接口，begin，end应该是最常见的两个接口，分别返回容器的首位置，以及实际存储元素位置的下一位。

注意，这两个接口应该都有对应的返回常量迭代器的重载版本。

iterator begin()
{
	return _start;
}

const_iterator begin() const
{
	return _start;
}

iterator end()
{
	return _finish;
}

const_iterator end() const
{
	return _finish;
}

4、size，capacity的实现

我们用size返回此时存储元素的多少，capacity返回此时开辟的空间大小。

size_t size()
{
	return _finish - _start;
}

size_t capacity()
{
	return _endOfStorage - _start;
}

5、reserve，push_back,pop_back的实现

根据算法的基本原理，push_back实际上本身就是检查空间是否满了，满了就先扩容，随后在确认空间足够的情况下 在尾部插入元素的接口。

避免频繁扩容的问题，我们使用 reserve 预分配足够的内存。

void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t oldsize = size();
		iterator tmp = new T[n];
		if (_start)
		{
			//这里不能使用memcpy，会引发浅拷贝的一些问题
			for (int i = 0; i < oldsize; ++i)
			{
				tmp[i] = _start[i];

			}
			delete[]_start;
		}
		_strat = tmp;
		_finish = _start + oldsize;
		_endOfStorage = _start + n;
	}
}

void push_back(const T& x)
{
	if (_endOfStorage == _finish)
	{
		size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
		reserve(newcapacity);
	}
	*finish = x;
	_finish++;
}

void pop_back()
{
	assert(size() > 0);
	_finish--;
}

6、构造函数，赋值重载，拷贝构造函数，析构函数，swap的实现

在大部分情况下，编译器默认生成的构造函数就足够我们使用，所以我们只需要实现拷贝构造与赋值重载函数就行了。

但是我们注意到，如果我们手动写的拷贝构造与赋值重载，编译器就不会自动生成默认的拷贝函数，为了防止这个问题，我们需要用default来强制让编译器生成。

在写赋值重载函数的时候，我们面临这一个抉择，我们可以实现现代写法swap，高效的实现赋值重载，所以，我们就需要先实现一个swap函数：

vector = default;//强制生成构造函数

vector(const vector<T>& v)//拷贝构造
{
	reserve(v.size());
	for (auto it : v)
	{
		push_back(it);
	}
}

vector<T>& operator= (vector<T> v)
{
	swap(v);
	return *this;
}

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

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

7、各种自定义类型迭代器的构造函数实现

我们发现，vector也支持其他自定义类型的迭代器传参，来构造。

为了接受不同的类型，所以我们又要使用模板来实现一个函数模板：
 

template<class InputIterator>
vector(InputIterator first, InputIterator last)//类模板中的函数模板,支持各种自定义类型的迭代器的构造
{
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}

8、[],resize的实现

为了向数组一样支持随机访问，我们需要对[]进行重载。

由于reserve()只修改capacity大小，不修改size大小，所以我们需要实现一个resize函数，既修改capacity大小，也修改size大小。

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

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

void resize(size_t n, const T& value = T())//调用T类型的默认默认构造函数
{
	if (n < size())
	{
		_finish = _start + n;
	}
	if (n > size())
	{
		reserve(n);
		while (_finish != _start + n)
		{
			push_back(value);
		}
	}
}

9、erase与insert的实现

erase与insert是vector容器接口中比较难实现的部分，不仅要检查是否越界，我们还要格外注意迭代器的失效问题，当然，为了解决迭代器的失效，我们需要返回新的迭代器，并在原来的使用中让原迭代器接受返回的迭代器：

 iterator insert(iterator pos, const T& x)
 {
     assert(pos <= _finish);
     assert(pos >= _start);

     if (_finish == _endOfStorage)
     {
         size_t oldsize = pos - _start;
         size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
         reserve(newcapacity);
         pos = _start + oldsize;
     }
     iterator i = _finish - 1;
     while (i >= pos)
     {
         *(i + 1) = *i;
         i--;
     }
     *pos = x;
     ++_finish;

     return  pos;
 }

 iterator erase(iterator pos)
 {
     assert(pos < _finish);
     assert(pos >= _start);

     iterator tmp = pos + 1;
     while (tmp < _finish)
     {
         *(tmp - 1) = *tmp;
         ++tmp;
     }
     --_finish;
     return pos;
 }

四、结语

Vector 容器在 C++ 编程中扮演着重要角色，其灵活性和高效性使其成为处理动态数组的首选。通过深入理解 vector 的机制和最佳实践，可以更高效地进行编程，充分发挥 C++ 的强大功能。

希望本文对你深入了解 C++ 中的 vector 容器有所帮助！