vector的模拟实现

在这里插入图片描述

文章目录

vector的模拟实现
一、vector模拟实现总览
二、模拟实现vector函数接口
- 1. 默认成员函数
- - 1.1. 构造函数
  - 1.2. 析构函数
  - 1.3.拷贝构造函数（深拷贝）
  - 1.4. 赋值运算符重载函数
- 2. 容量操作函数
- - 2.1. size和capacity
  - 2.2. resize
  - 2.3. reserve
  - 2.4. empty
- 3. 修改操作函数
- - 3.1. push_back
  - 3.2. pop_back
  - 3.3. insert
  - 3.4. erase
  - 3.5. swap
  - 3.6. clear
- 4.元素访问函数
- - 4.1. operator[ ]运算符重载
  - 4.2. front和back
- 5.迭代器

一、vector模拟实现总览

vector中有三个成员变量分别是_ start、_ finish、_endofstorage，他们的类型均为迭代器。

_ start 指向容器的头，_ finish 指向有效数据的尾，_endofstorage 指向整个容器的尾。

namespace vector_realize
{
	//模拟实现vector
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		//默认成员函数
		vector();                                           //无参构造函数
		vector(size_t n, const T& val);                     //带参构造函数
		template<class InputIterator>                      
		vector(InputIterator first, InputIterator last);    //迭代器构造函数
		vector(const vector<T>& v);                         //拷贝构造函数
		vector<T>& operator=(const vector<T>& v);           //赋值运算符重载函数
		~vector();                                          //析构函数

		//迭代器相关函数
		iterator begin();
		iterator end();
		const_iterator begin() const;
		const_iterator end() const;
        

		//容量和大小相关函数
		size_t size() const;
		size_t capacity() const;
		void reserve(size_t n);
		void resize(size_t n, const T& val = T());
		bool empty() const;

		//修改容器内容相关函数
		void push_back(const T& x);
		void pop_back();
		void insert(iterator pos, const T& x);
		iterator erase(iterator pos);
		void swap(vector<T>& v);

		//访问容器相关函数
		T& operator[](size_t pos);
		const T& operator[](size_t pos) const;
        T& front();
		T& back();
		const T& front() const; 
        const T& back() const ;

	private:
		iterator _start;        //指向容器的头
		iterator _finish;       //指向有效数据的尾
		iterator _endofstorage; //指向容器的尾
	};
}

二、模拟实现vector函数接口

1. 默认成员函数

1.1. 构造函数

1、无参构造函数

vector容器支持一个无参构造函数，这里我们只需要把每个成员变量初始化为空指针即可。
// 构造函数
vector() // --> 无参构造函数
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstorage(nullptr)
{}
2、带参构造函数

vector的带参构造函数首先在初始化列表对基本成员变量初始化，在将迭代器区间在[first, last)的数据一个个尾插到容器当中即可：
// --> 迭代器构造
// 若使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器
// 重新声明迭代器，迭代器区间[first,last)可以是任意容器的迭代器
template<class InputIterator>
vector(InputIterator first, InputIterator last)
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstorage(nullptr)
{   
    while (first != last)
	{
		push_back(*first);
		first++;
	}
 }
3、用n个val去初始化vector

vector的构造函数还支持用n个val去初始化，只需要先调用reserve函数开辟n个大小的空间，再利用for循环把val的值依次push_back尾插进去即可。
// 带参构造函数 --> 初始化容器为n个val
vector(size_t n, const T& val = T())
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstorage(nullptr)
{
	reserve(n);
	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}
这样写会出现一个问题：内存寻址错误。当我想实现下面的语句时：
vector<int> v1(10, 5);
vector<char> v2(10, 'A');
这里我调用的地方两个参数都是int，此时调用构造函数时匹配的是第二个传迭代器区间的构造函数，导致这样的原因在于编译器会优先寻找最匹配的那个函数。此构造函数的第一个参数是unsigned int类型，所以不会优先匹配此构造函数。因此我们需要再重载一个第一个参数为int类型的构造函数即可解决，并且STL库里面也重载long版本，这里一并加上。
// 重载1
vector(long n, const T& val = T())
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	reserve(n);
	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}

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

1.2. 析构函数

析构容器时，应该先判断容器是否为空，如果为空，则不需要析构操作。如果不为空，则先释放容器的存储空间，然后将各个成员变量赋值为空指针即可。
//析构函数
~vector()
{
   	if(_start)
   	{
      		delete[] _start;
		_start = _finish = _endofstorage = nullptr;
   	}
}

1.3.拷贝构造函数（深拷贝）

拷贝构造这里同样涉及深拷贝，有这里我们仍然提供两种写法：传统写法和现代写法。

1、传统写法：

传统写法就是先开辟一块与原来容器大小相同的空间，然后将容器中的数据一个一个拷贝过来即可，最后更新_ finish 和 _ endofstorage 即可。
//拷贝构造函数
// 拷贝构造 v1(v)
// 传统写法
vector(const vector<T>& v)
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstorage(nullptr)
{
	_start = new T[capacity()]; // 开辟一块和v大小相同的空间
	// memcpy(_start, v._start, sizeof(T) * size()); error
	for (size_t i = 0; i < size(); i++)
	{
		_start[i] = _v[i];
	}
	_finish = _start + size();
	_endofstorage = _start + capacity();
}
注意：这里不能用memcpy拷贝数据，原因下一篇博客细讲。

2、现代方法：

我们在string类的现代方法知道，要完成深拷贝，自己不想完成，就让别人完成，然后和别人互换劳动成果。vector也是一样。

假设我要用v1拷贝v2，首先对基本成员变量进行初始化，然后我创建tmp对象将要拷贝的数据利用构造函数去传递过去，再利用swap函数把tmp对象的成员函数全部与v1交换即可完成现代方法的深拷贝。
// 现代写法1
vector(const vector<T>& v)
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstorage(nullptr)
{
	vector<T> tmp(v.begin(), v.end()); // 调用迭代器构造函数
	swap(tmp);
}
还有一种比较巧妙的方法，使用范围for（其他遍历方式也行）对容器v进行遍历，在遍历过程中将容器v中的数据一个一个尾插进去即可。
// 现代写法1
vector(const vector<T>& v)
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstorage(nullptr)
{
	reverse(v.capacity());
	for (const auto& e : v)
	{
		push_back(e);
	}
}
注意：范围for这里一定要加上引用，不加引用会发生拷贝，如果是自定义类型的话，会调用拷贝构造，时间空间开销都比较大，如果是浅拷贝可能还有其他问题。并且引用可以节省内存空间，提高效率。

1.4. 赋值运算符重载函数

vector的赋值运算符重载也涉及深拷贝问题，这里我们依然有传统方法和现代方法。

1、传统写法：
思路：

首先仍然是判断是否自己给自己赋值，自己给自己赋值倒是不会报错，但是会付出代价，比如又重新开辟一块内存空间，然后进行深拷贝，消耗了时间和空间。所以我们尽量避免。如果不是自己给自己赋值，那么我们先开辟一块和容器一样大的空间，然后将容器v中的数据一个一个拷贝过来，之后释放原来的空间，更新新空间的地址。最后更新_ finish 和_ endofstorage。
//赋值运算符重载 --> 深拷贝
// 传统写法
// v1 = v; 赋值重载 v1.operator=(&v1, v);
vector<T>& operator=(const vector<T>& v)
{
	if (this != &v) // 防止自己给自己赋值
	{
		T* tmp = new T[capacity()];
        // memcpy(tmp, _start, sizeof(T) * size()); ——> 浅拷贝问题，不能使用
		for (size_t i = 0; i < size(); i++)
		{
			tmp[i] = _start[i]; // 调用T类的赋值运算符重载函数进行深拷贝
		}
		delete[] _start;
		_start = tmp;

		_finish = _start + size();
		_endofstorage = _start + capacity();
	}

	return *this; 
}
注意：

1、这里我们不能使用memcpy，浅拷贝会导致程序报错，这个内容我们下一篇会重点讲解。

2、C语言的动态开辟内存malloc需要检查合法性，而C++的new不需要，new失败的话需要抛异常捕获。

2、现代写法：

我们在学习string类的时候实现了赋值运算符重载的现代方法，本质就是剥削，vector也是一样，找到一个中间变量，让他去完成深拷贝，我们直接与他交换，白嫖了人家的劳动成果。这里的现代方法和上文拷贝构造的现代方法差不多，只不过多了一个返回值。具体操作如下：
//法一：基础版
// 拷贝构造
vector<T>& operator=(const vector<T>& v)
{
	if (this != &v)
	{
        //vector<T> tmp(v.begin(), v.end()); // 构造函数
		vector<T> tmp(v); // 拷贝构造
		swap(tmp);
	}

	return *this;
}
这里还有另一种更加简洁的现代方法，上述写法是引用传参，这里我们可以直接传值传参，让编译器自动调用拷贝构造函数，再把拷贝出来的对象作为右值与左值交换即可。传值并没有权限放大问题，所以不需要const修饰，权限问题出现在指针和引用的使用中。
// 简化版 -- 不能检查自己给自己赋值
// v1 = v2; 
// v1 = v1; 
vector<T>& operator=(vector<T> v)//传值传参调用拷贝构造
{
	swap(v);
	return *this;
}
不过这种简洁的版本无法避免自己给自己赋值，但很少会出现自己给自己赋值的行为，即使出现这种行为，程序也并不报错，所以我们也可以使用这种方法。

2. 容量操作函数

2.1. 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 _endofstorage - _start;
}

2.2. resize

resize扩容规则：

如果 n 大于当前容器的capacity()，则重新分配一块更大的存储空间，并把原来的数据原封不动的拷贝过来。
如果 n 大于当前容器 size()，则通过在末尾插入所需数量的元素来扩展内容，以达到 n 的大小。如果指定了 val，则新元素将初始化为 val 的副本，否则，它们将被值初始化。
n 大于当前容器 size()，则内容将减少到其前 n 个元素，删除超出的元素（并销毁他们）。
//假如size = 5, capacity = 10
// n > 10 扩容+填充数据
// 5 < n <= 10 填充数据
// n <= 5 删除数据
//利用T()匿名对象调用默认构造函数的值进行初始化，这样写说明C++的内置类型也有自己的构造函数
void resize(size_t n, T val = T())		
{	// 1.空间不够增容
	if (n > capacity())
	{
		reserve(n);
	}
	// 2.n > size(),填充数据,将size()扩大到n
    //然后把有效数据_finish到_start + n之间的数据置为缺省值val

	if (n > size())
	{
		while (_finish < _start + n)
		{
			*_finish = val;
			_finish++;
		}
	}
	else
	{
		//3.n < size(), 将数据个数缩小到n
		_finish = _start + n;
	}
}
**补充：**C++的内置类型也有自己的构造函数和析构函数，这样才能更好的支持模板。
void test()
{
	int i = 0;
	int j = int();
	int k = int(2);
	cout << i << endl;//0
	cout << j << endl;//0
	cout << k << endl;//2
}

2.3. reserve

reserve扩容规则：

如果 n 大于当前容器的capacity()，则该函数会导致容器重新分配其存储空间，将其capacity()增加到 n（或更大）。
在所有其他情况下，函数调用不会导致重新分配，并且容器的capacity()不受影响。

reserve扩容和string的扩容非常相似。先判断参数n是否大于当前容器的capacity()（否则不做任何操作），如果大于当前容器的capacity()，先开辟一块新的扩容的空间，如果原来的空间里面有数据，那么就利用for循环将容器中的数据一个一个拷贝到新空间，再释放旧空间，最后指向新空间。如果没有，直接指向新空间即可。
//reserve扩容
void reserve(size_t n)
{
	int oldSize = size();
	if (capacity() < n)
	{
		// 1.开辟新空间
		T* tmp = new T[n];
		if (_start)
		{
			//2.拷贝元素
			// 这里直接用memcpy会有问题，发生浅拷贝
			//memcpy(tmp, _start, sizeof(T) * size());
			for (size_t i = 0; i < oldSize; i++)
			{
				tmp[i] = _start[i]; // 本质调用赋值运算符重载进行深拷贝
			}
			//3. 释放旧空间
			delete[] _start;
		}
		_start = tmp;
	}
	// 这里_start的地址变了，而_finish还是原来的位置
	//_finish = _start + size(); error 
	_finish = _start + oldSize;
	_endofstorage = _start + n;
}
补充1：

在扩容结束后要记得更新_ finish和_ endofstoage，这里的_ finsh要加上原先的size()长度，要先用变量oldSize保存下来，否则之后扩容后会更改指针的指向由原先的_start变为tmp，这里直接+ size()函数的返回值会导致结果为随机值。

补充2：

不能使用memcpy进行数据拷贝，因为memcpy是浅拷贝，它会将一段内存空间中内容原封不动的拷贝到另外一段内存空间中，导致后续delete时拷贝过的数据一并给delete了，具体我下篇博客细讲。

2.4. empty

empty函数可以直接比较当前容器中的_ start 和 _ finish指针是否相等来判断容器是否为空，若相等，则为空，反正，不为空。
bool empty() const
{
    return _start == _finish;
}

3. 修改操作函数

3.1. push_back

push_back尾插和之前写过的尾插没什么区别，先判断是否需要扩容，然后把尾插的值赋值过去，最后更新有效数据地址_ finish即可：
void push_back(const T& x)
{
	// 判断是否需要扩容
	if (_finish == _endofstorage)
	{
		int newCapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newCapacity);
	}
	*_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()时，就是尾插
}

3.2. pop_back

首先判断_ finish是否大于_ start，若大于，直接_finsh–即可，也可以调用 !empty()函数，若容器为空，则不需要操作。
void pop_back()
{
    //判断是否可以进行删除
	if (_finish > _start)
	{
		_finish--;
	}
	/*assert(!empty());
	_finish--;*/
}
pop_back也可以复用下文的erase实现，当erase的参数为_ finish时，实现的就是尾删，而_ finish可以通过调用迭代器end()函数来解决。
void pop_back()
{
	//法二：复用erase
	erase(end() - 1);
 //不能用end()--，因为end()是传值返回，返回的是临时对象，临时对象具有常性，不能自身++或--，因此要用end() - 1
}

3.3. insert

首先要检查插入的位置是否越界，再插入数据之前判断是否需要扩容。之后再挪动数据，最后把值插入指定位置。

注意：

注意扩容以后，pos就失效了，要记得更新pos，否则会发生迭代器失效。可以通过设定变量len来计算扩容前pos指针位置和_ start指针位置的相对距离，最后在扩容后，让_start再加上先前算好的相对距离len，就得到了更新后的pos指针的位置了。其实这里还有一个迭代器失效的问题，我们下一篇迭代器失效的博客再细讲。下面给出优化修改后的insert：
// 迭代器失效 : 野指针问题
// 不能保证原地扩容，扩容就会导致迭代器失效：地址变化了 
iterator insert(iterator pos, const T& val)
{
	assert(pos >= _start);
	assert(pos <= _finish);
    // aasert(pos >= _start && pos <= _finish); 这样也可以，不过无法快速判断哪个原因
	if (_finish == _endofstorage)
	{
		size_t len = pos - _start;
		int newCapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newCapacity);
		// 扩容会导致迭代器失效，需要重新修改数据pos
		pos = _start + len;
	}
	// 挪动数据
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		end--;
	}
	// 插入数据
	*pos = val;
	_finish++;

	return pos;
}

3.4. erase

首先要检查删除位置pos的合法性，其次从pos + 1的位置开始往前覆盖即可删除pos位置，最后记得返回的值为删除位置的下一个位置，其实返回的就是pos，因为在pos删除后，下一个值会覆盖到pos的位置上。
iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);
	iterator begin = pos + 1;
	while (begin < _finish)
	{
		*(begin - 1) = *begin;
		begin++;
	}
	_finish--; 

	return pos; //返回pos的下一个位置
}
补充1：

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

补充2：

erase也会存在失效，erase的失效是意义变了，或者不存在有效访问数据有效范围。
一般不会使用缩容的方案，那么erase的失效，一般也不存在野指针的失效。

下一篇博客会仔细分析迭代器失效问题，这里先给出结论：

erase(pos)以后pos失效了，pos的意义变了，但是在不同平台下面对于访问pos的反应是不一样的，我们用的时候要以失效的角度去看待此问题。
对于insert和erase造成迭代器失效问题，linux的g++平台检查并不是很严格，基本靠操作系统本身野指针越界检查机制。windows下VS系列检查更严格一些，使用一些强制检查机制，意义变了可能会检查出来。
虽然g++对于迭代器失效检查时是并不严格，但是套在实际场景中，迭代器意义变了，也会出现各种问题。

3.5. swap

swap函数用于交换两个容器的数据，我们可以直接调用库里面的swap函数将两个容器当中的各个成员变量进行交换即可。
//交换函数
void swap(vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_endofstoage, v._endofstoage);
}
补充1：

在调用库里面的swap的时候需要加上std::（作用域限定域），编译器这里优先在库里面寻找swap函数，否则编译器会根据就近原则，调用命名空间你自己实现的swap函数。

补充2：

这里我们在传参的时候不能加上const修饰，因为swap交换两个对象，导致容器v的内容改变了。

3.6. clear

只需要把起始位置的指针_ start赋给有效数据指针_ finish即可完成数据的清空。
//clear清空数据
void clear()
{
	_finish = _start;
}

4.元素访问函数

4.1. operator[ ]运算符重载

直接返回pos位置的数据即可进行下标+[ ]的方式进行访问。
//operator[]运算符重载
T& operator[](size_t n)
{
	assert(n < size());
	return _start[n];
}
为了方便const对象也可以调用[ ]运算符重载，因此还推出了一个const版本的[ ]运算符重载。
const T& operator[](size_t n) const
{
	assert(n < size());
	return _start[n];
}

4.2. front和back

front访问第一个元素，back访问最后一个元素这两个没什么用，因为可以用operator[]代替，大家知道就行了。
T& front()
{
	return *_start;
}

T& back()
{
	return *(_finish - 1);
}
为了方便const对象也可以调用，因此还推出了一个const版本的访问函数。
const T& front() const
{
	return *_start;
}

const T& back() const
{
	return *(_finish - 1);
}

5.迭代器

vector的begin直接返回容器的_ start起始位置即可，vector的end返回容器的_finish的位置。
typedef T* iterator;

iterator begin()
{
	return _start;
}

iterator end()
{
	return _finish;
}
这里迭代器同样也要考虑到const对象调用的可能性，使得const对象调用begin()和end()函数时得到的迭代器只能对数据进行只读操作，不能修改。因此推出const版本的迭代器如下：
//const版本迭代器
typedef const T* const_iterator;

const_iterator begin() const
{
	return _start;
}

const_iterator end() const
{
	return _finish;
}
这里大家在看vector使用迭代器的代码就会非常清晰，实际就是使用指针遍历容器，如下：
vector<int> v(10, 1);
vector<int>::iterator it = v.begin();
while(it != v.end())
{
    cout << *it << " "
    it++；
}
cout << endl;
我们之前说过范围for的底层是迭代器，我们实现了迭代器，也可以使用范围for遍历容器，因为在编译器编译时会自动将范围for替换为迭代器的形式，记住这是傻瓜式的替换，意思是你的迭代器不能修改，比如我们把begin变成Begin，这时候范围for就编译不过去了。
vector<int> v(10, 1);
for(auto e : v)
{
    cout << e << " ";
}
cout << endl;