【STL】模拟实现vector

目录

1、基本成员变量

2、默认成员函数 

构造函数

析构函数

拷贝构造函数 

赋值运算符重载函数

3、容器访问相关函数接口 

operator [ ]运算符重载

迭代器 

范围for

4、vector容量和大小相关函数

size和capacity

reserve扩容

resize

swap交换数据 

empty 

5、修改容器内容相关函数

push_back尾插

insert

pop_back尾删

erase 

clear清空数据 

---

1、基本成员变量

namespace Fan
{
	template <class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
	private:
		iterator _start;        //指向容器的头
		iterator _finish;       //指向有效数据的尾
		iterator _endofstoage;  //指向容器的尾
	};
}

---

2、默认成员函数 

构造函数

• 1、无参构造函数

我们只需要把每个成员变量初始化为nullptr即可。

//无参构造函数
vector()
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstoage(nullptr)
{}

• 2、带参构造函数

vector的带参构造函数首先在初始化列表对基本成员变量进行初始化，然后将迭代器区间在[first, last)的数据一个个尾插到容器当中即可。

//带参构造函数
template <class InputIterator>
vector(InputIterator first, InputIterator last)
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstoage(nullptr)
{
	//将迭代器区间在[first,last)的数据一个个尾插到容器当中
	while (first != last)
	{
		push_back(*first);
		first++;
	}
}

• 3、用n个val去初始化vector

vector的构造函数还支持用n个val去进行初始化，只需要先调用reserve函数开辟n个大小的空间，然后用for循环把val的值依次push_back尾插进去即可。

//用n个val来构造vector
vector(size_t n, const T& val = T())
	: _start(nullptr)
	, _finish(nullptr)
	, _endofstoage(nullptr)
{
	reserve(n);
	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}

⚠：注意

此时会出现一个问题：内存寻址错误。当我们实现下面的语句时：

Fan::vector<int> v(5, 4);

对于构造函数3而言其两个参数类型为size_t和相对应模板数据类型。而对于构造函数2，其两个参数类型都为迭代器。我们上述代码调用的地方两个参数都是int，此时调用构造函数时匹配的是第二个传迭代器区间的构造函数，导致这样的原因在于编译器会优先寻找最匹配的那个函数。为了解决这一问题，我们还需要重载一个第一个参数类型为int类型的构造函数。

vector(int n, const T& val = T())
	: _start(nullptr)
	, _finish(nullptr)
	, _endofstoage(nullptr)
{		
    reserve(n);
	for (int i = 0; i < n; i++)
	{
		push_back(val);
	}
}

---

析构函数

首先我们判断该容器_start是否为空，不为空就释放空间+置空即可。

//析构函数
~vector()
{
	if (_start) //避免释放空指针
	{
		delete[] _start; //释放容量所指向的空间
		_start = _finish = _endofstoage = nullptr; //置空
	}
}

---

拷贝构造函数 

• 传统写法

拷贝构造传统写法的思想是我们最容易想到的：先开辟一块与该容器大小相同的空间，然后将容器当中的数据一个个拷贝过来即可，最后更新_finish和_endofstorage即可。

//传统写法
vector(const vector<T>& v)
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstoage(nullptr)
{
	_start = new T[v.capacity()];  //开辟一块和容器V大小相同的空间
	for (size_t i = 0; i < v.size(); i++) //将容器v中的数据一个个拷贝过来
	{
		_start[i] = v[i];
	}
	_finish = _start + v.size(); 
	_endofstoage = _start + v.capacity();
}

注意：将容器中的数据一个个拷贝过来时不能够用memcpy函数，当vector存储的数据是内置类型或者是无需深拷贝的自定义类型时，使用memcpy函数并没有什么问题，但是当vector存储的数据是需要进行深拷贝的自定义类型，那么使用memcpy就会存在弊端。例如，当vector存储的数据是string类的时候。

vector当中存储的每一个string都指向自己所存储的字符串。

如果此时我们使用的是memcpy函数进行拷贝构造的话，那么拷贝构造出来的vector当中存储的每个string的成员变量值将与被拷贝的vector当中存储的每个string的成员变量值相同，即两个vector当中的每个对应的string成员都指向同一个字符串空间。

这显然并不是我们想要的结果，那么我们所给的代码是如何解决了这个问题呢？

总结： 如果vector当中存储的数据类型是内置类型(int)或深拷贝的自定义类型(Date),使用memcpy函数进行拷贝构造是没有问题的，但如果vector当中存储的数据类型是深拷贝的自定义类型(string)，则使用memcpy函数将不能达到我们想要的结果。

• 现代写法

拷贝构造我们可以仿照string的现代方法拷贝构造思路。首先对基本成员变量进行初始化，然后创建一个tmp的模板将要拷贝的数据利用构造函数传递过去，然后再将这个tmp模板与自己交换即可。

//拷贝构造函数
vector(const vector<T>& v)
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstoage(nullptr)
{
	vector<T> tmp(v.begin(), v.end()); //调用构造函数
	swap(tmp);
}

---

赋值运算符重载函数

• 传统写法

首先判断是否是给自己赋值，若是给自己赋值则无需进行操作。若不是给自己赋值，则先开辟一块和容器V大小相同的空间，然后将容器V当中的数据一个个拷贝过来，最后更新_finish和_endofstorage的值即可。

//传统写法
vector<T>& operator=(const vector<T>& v)
{
	if (this != &v) //防止自己给自己赋值
	{
		delete[] _start; //释放原来的空间
		_start = new T[v.capacity()]; //开辟一块和容器v大小相同的空间
		for (size_t i = 0; i < v.size(); i++) //将容器v当中的数据一个个拷贝过来
		{
			_start[i] = v[i];
		}
		_finish = _start + v.size(); //容器有效数据的尾
		_endofstorage = _start + v.capacity(); //整个容器的尾
	}
	return *this; //支持连续赋值
}

注意：和拷贝构造的传统写法类似，这里也不能使用memcpy函数进行拷贝。

• 现代写法

我们这里直接用传值传参，不用引用传参。利用vector调用构造函数返回的值与左值swap交换。

//赋值运算符重载
vector<T>& operator=(vector<T> v) //调用构造
{
	this->swap(v); //交换两个对象
	return *this;
}

---

3、容器访问相关函数接口 

operator [ ]运算符重载

直接返回pos位置的数据即可进行下标+[ ]的方式进行访问

//operator[]运算符重载
T& operator[](size_t pos)
{
	assert(pos < size()); //检测pos的合法性
	return _start[pos];
}

为了方便const对象也可以调用[ ]运算符重载，我们还需要写一个const版本的[ ]运算符重载。

//const版本的[]运算符重载
const T& operator[](size_t pos)const
{
	assert(pos < size()); //检测pos的合法性
	return _start[pos];
}

---

迭代器 

vector的begin直接返回容器的_start，end返回容器的_finish。

//begin
iterator begin()
{
	return _start; //返回容器的起始位置
}
//end
iterator end()
{
	return _finish; //返回有效数据下一个的地址
}

const版本：

//const版本迭代器
const_iterator begin()const
{
	return _start;
}
//end
const_iterator end()const
{
	return _finish;
}

---

范围for

现在我们实现了迭代器，实际上也就可以使用范围for遍历容器，因为编译器在编译时会自动将范围for替换成迭代器的形式。

vector<int> v(5, 3);
//范围for进行遍历
for (auto e : v)
{
	cout << e << " ";
}
cout << endl;

---

4、vector容量和大小相关函数

size和capacity

因为指针相减的结果就是这两个指针之间对应类型的数据个数，所以获取size只需_finish-_start。获取capacity只需_endofstoage-_start。

• size函数：

size_t size() const //最好加上const，普通对象和const对象均可调用
{
	return _finish - _start; //指针相减就能得到size的个数
}

• capacity函数：

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

---

reserve扩容

reserve扩容思路在模拟实现string讲过，这里不再多赘述。

//reserve扩容
void reserve(size_t n)
{
	size_t sz = size();//提前算出size()的大小，方便后续更新_finish
	if (n > capacity())
	{
		T* tmp = new T[n];
		if (_start)//判断旧空间是否有数据
		{
			//不能用memcpy，因为memcpy是浅拷贝
			for (size_t i = 0; i < size(); i++)
			{
				tmp[i] = _start[i];//将容器当中的数据一个个拷贝到tmp当中
			}
			delete[] _start;//释放旧空间
		}
		_start = tmp;//指向新空间
	}
	//更新_finish和_endofstoage
	_finish = _start + sz;
	_endofstoage = _start + n;
}

这里有两个需要注意的地方：

• 在进行操作之前需要提前记录当前容器当中有效数据的个数。

因为我们最后需要更新_finish指针的指向，而_finish指针的指向就等于_start指针加上容器当中有效数据的个数，当_start指针的指向改变后我们再调用size函数通过_finish-_start计算出的有效数据的个数就是一个随机值了。此时就会出bug。

• 拷贝容器当中的数据时，不能够使用memcpy函数进行拷贝。 

memcpy是浅拷贝，当我们vector当中存储的是string类的时候，使用memcpy函数reserve出来的容器与原容器当中每个对应的string成员都指向同一个字符串空间。当我们释放原容器空间的时候，原容器当中存储的每个string在释放时会调用string的析构函数，将其指向的字符串也进行释放。所以使用memcpy函数reserve出来的容器当中的每一个string所指向的字符串实际上是一块已经被释放的空间，访问该容器时就是对内存空间进行非法访问。

所以我们还是需要用for循环将容器当中的string一个个赋值过来，因为这样能够间接调用string的赋值运算符重载，实现string的深拷贝。

---

resize

1. 如果 n 小于当前容器的size()，则内容将减少到其前 n 个元素，删除超出（并销毁）的元素。
2. 如果 n 大于当前容器 size()，则通过在末尾插入所需数量的元素以达到 n 的大小来扩展内容。若指定了 val，则新元素将初始化为 val 的副本，否则，它们将进行值初始化。
3. 如果 n 也大于当前容器容量capacity()，则会自动重新分配分配的存储空间。

//resize
//void resize(size_t n, T val = T())
void resize(size_t n, const T& val = T()) //利用T()调用默认构造函数的值进行初始化，这样写说明C++的内置类型也有自己的构造函数
{
	//如果 n > capacity()容量，就需要扩容
	if (n > capacity())
	{
		reserve(n);
	}
	//如果 n > size()，就需要把有效数据_finish到_start + n之间的数据置为缺省值val
	if (n > size())
	{
		while (_finish < _start + n)
		{
			*_finish = val;
			_finish++;
		}
	}
	//如果 n < size()，更新有效数据到_start + n
	else
	{		
    	_finish = _start + n;
	}
}

• 补充：在C++当中内置类型也可以看作是一个类，它们也有自己的默认构造函数，数据类型默认值为0，指针为空。这样也能更好的支持模板，所以我们在给resize函数的参数val设置缺省值时，设置为T()即可。

void test()
{
	int i = 0;
	int j = int();
	int k = int(1);
	cout << i << endl;//0
	cout << j << endl;//0
	cout << k << endl;//1
}

---

swap交换数据 

我们直接调用库函数里面的swap去进行成员变量的交换即可。

//交换函数
void swap(vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_endofstoage, v._endofstoage);
}

---

empty 

empty函数可以直接通过比较容器当中的_start和_finish指针的指向来判断容器是否为空，若指向的位置相同，则该容器为空。

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

---

5、修改容器内容相关函数

push_back尾插

要尾插首先要判断是否需要扩容，把尾插的值赋过去，再更新有效数据地址_finish即可。

void push_back(const T& x)
{
	//检测是否需要扩容
	if (_finish == _endofstoage)
	{
		size_t newcapcacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapcacity);
	}
	*_finish = x;
	_finish++;
}

这里的push_back还可以复用下文实现好的insert进行尾插，当insert中的pos为_finish时，insert实现的就是push_back尾插。而_finish可以通过调用迭代器end函数来解决。

void push_back(const T& x)
{
	//法二：复用insert
	insert(end(), x); //当insert中的参数pos为end()时，就是尾插
}

---

insert

insert函数可以在所给迭代器pos位置插入数据，在插入数据前先判断是否需要增容，然后将pos位置及其之后的数据统一向后挪动一位，以留出pos位置进行插入，最后将数据插入到pos位置即可。

⚠注意：注意扩容以后，pos就失效了，要记得更新pos，否则就会发生迭代器失效。（迭代器失效问题我们在下一篇文章讲）我们可以通过设定变量n来计算扩容前pos指针位置和_start指针位置的相对距离，最后在扩容后，让_start再加上先前算好的相对距离n就是更新后的pos指针的位置了。

//insert
iterator insert(iterator pos, const T& x)
{
	//检测参数合法性
	assert(pos >= _start && pos <= _finish);
	//检测是否需要扩容
	/*扩容以后pos就失效了，需要更新一下*/
	if (_finish == _endofstoage)
	{
		size_t n = pos - _start;//计算pos和start的相对距离
		size_t newcapcacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapcacity);
		pos = _start + n;//防止迭代器失效，要让pos始终指向与_start间距n的位置
	}
	//挪动数据
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *(end);
		end--;
	}
	//把值插进去
	*pos = x;
	_finish++;
	return pos;
}

---

pop_back尾删

我们首先判断_finish是否大于_start，如果大于，直接_finish--即可，否则什么也不需要操作。

void pop_back()
{
	if (_finish > _start)//判断是否可以进行删除
	{
		_finish--;
	}
}

pop_back也可以复用下文的erase实现，当erase的参数为_finish时，实现的就是尾删，而_finish可以通过调用迭代器end()函数来解决。

void pop_back()
{
	//法二：复用erase
	erase(end() - 1);
    //不能用end()--，因为end()是传值返回，返回的是临时对象，临时对象具有常性，不能自身++或--，因此要用end() - 1
}

---

erase 

首先要检查删除位置pos的合法性，其次从pos+1位置开始往前覆盖即可删除pos位置，最后返回的值为删除位置的下一个位置，其实返回的就是pos，因为在pos删除后，下一个值会覆盖到pos的位置上。

//erase
iterator erase(iterator pos)
{
	//检查合法性
	assert(pos >= _start && pos < _finish);
	//从pos + 1的位置开始往前覆盖，即可完成删除pos位置的值
	iterator it = pos + 1;
	while (it < _finish)
	{
		*(it - 1) = *it;		
        it++;
	}
	_finish--;
	return pos;
}

• 补充1：

一般vector删除数据，都不考虑缩容的方案，当size() < capacity() / 2 时，可以考虑开一个size()大小的新空间，拷贝数据，释放旧空间。缩容的本质是时间换空间。一般设计不会考虑缩容，因为实际比较关注时间效率，不是太关注空间效率，因为现在硬件设备空间都比较大，空间存储也比较便宜。

• 补充2：

1. erase也会存在迭代器失效，erase的失效是意义变了，或者不存在有效访问数据范围。
2. 一般不会使用缩容的方案。那么erase的失效一般也就不存在野指针导致的失效。
3. erase(pos)以后pos失效了，pos的意义变了，但是在不同平台下面对于访问pos的反应是不一样的，我们用的时候要以失效的角度去看待此问题。
4. 对于insert和erase造成迭代器失效问题，linux的g++平台检查很佛系，基本靠操作系统本身野指针越界检查机制。windows下VS系列检查更严格一些，使用一些强制检查机制，意义变了可能会检查出来。
5. 虽然g++对于迭代器失效检查时是非常佛系的，但是套在实际场景中，迭代器意义变了，也会出现各种问题。

---

clear清空数据 

只需要把起始位置的指针_start赋给有效数据指针_finish即可完成数据的清空。

//clear清空数据
void clear()
{
	_finish = _start;
}