【C++】---STL之vector的模拟实现

一、vector在源码中的结构：

vector的成员变量：
start，finish，end_of_storage的返回类型都是迭代器！

他的成员变量是三个迭代器：
（1）start：指向第1个元素（开始）
（2）finish：指向数据的结束
（3）end_of_storage：指向空间的结束

二、vector类的实现：

实现以下vector相关内容：

1、vector的构造

1、无参数构造，构造出一个空容器：

//1、构造函数:
		vector()// 空的构造函数，所有变量都初始化为空！
			:_start(nullptr)
			,_finish(nullptr)
			, _end_of_storage(nullptr)
		{

		}

2、填充构造函数 向容器中插入n个值为val的元素

// 1.1 填充构造函数 向容器中插入n个值为val的元素
		vector(size_t n, const T& val)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(n);
			while (n)
			{
				push_back(val);
				n--;
			}
		}

3、完整代码：

#include<iostream>
#include<string>

using namespace std;

namespace yjl
{
	template<class T>
	class vector
	{
	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	public:
		//1、构造函数:
		vector()// 空的构造函数，所有变量都初始化为空！
			:_start(nullptr)
			,_finish(nullptr)
			, _end_of_storage(nullptr)
		{

		}

		// 1.1 填充构造函数 向容器中插入n个值为val的元素
		vector(size_t n, const T& val)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(n);
			while (n)
			{
				push_back(val);
				n--;
			}
		}

	};
}

2、析构

// 2、析构
		~vector()
		{
			if (_start)
			{
				delete[] _start;// 释放空间！
			}
			_start = _finish = _end_of_storage = nullptr;
			// 对vector的三个迭代器置空！
		}

3、拷贝构造

1、传统的写法：

注意： 当我们不写vector的拷贝构造函数，编译器会自动生成一份，但编译器生成的只能完成数据的浅拷贝，然而vector的三个成员变量都是迭代器，也就是指针T*，如果T是内置类型，那么就不会出现问题，但是如果T是自定类型，会出现拷贝对象和被拷贝对象指向同一块空间，根据后定义的先析构的原则，此程序会析构两次，会导致程序崩溃

	// 3、拷贝构造：
		// (1)传统写法：v1(v)
		vector(const vector<T>& v)
		{
			// 1.申请空间
			_start = new T[v.capacity()];
			// 2.拷贝数据
			for (int i=0;i<v.size();i++)
			{
				_start[i] = v._start[i];
			}
			// 3.更新数据
			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();
		}

2、现代的拷贝构造：开空间+逐个尾插

使用现代的拷贝构造时必须初始化，否则_start、_finish、_end_of_storage都是随机值，拷贝数据时可能会导致越界。如果T是自定义类型，那么会调用T的拷贝构造函数进行深拷贝

//(2)现代写法：复用
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			// 1.先开空间：reserve
			reserve(v.capacity());
			// 2.逐个尾插
			for (auto& e : v)
			{
				push_back(e);
			}
		}

4、赋值运算符重载

1、传统的赋值运算符重载：

	// 4、赋值运算符重载
		// (1)传统写法：
		vector<T> operator=(vector<T> v)
		{
			if (this != v)
			{
				delete[] _start;// 如果赋值运算符(=)，左右两边不相等，我直接把调用该函数的this清空，
				//然后把右边的值赋给左边，后面的代码相当于前面的拷贝构造

				// 1.申请空间
				_start = new T[v.capacityu()];
				// 2.拷贝数据
				for (size_t i = 0; i < v.size(); i++)
				{
					_start = v._start[i];
				}
				// 3.更新数据
				_finish = _start + v.size();
				_end_of_storage = _start + v.capacity();
			}
			
		}

2、现代写法：

		// (2)现代写法：
		// v1 = v2  (在成员函数中，v1调用operator=，v1就是this指针，v2相当于 v )

		vector<T>& operator=(vector<T> v)//这里面的参数故意没有传引用，目的就是不改变原来v2的值！！！
		{
			swap(v);//swap是库里的的成员函数，有隐含的this指针！(即：v1 )
			return *this;
		}
		viod swap(vector<T> v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_end_of_storage, v._end_of_storage);
		}

5、迭代器

（1）普通迭代器

iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}

（2）const迭代器

		const iterator begin()const
		{
			return _start;
		}
		const iterator end()const
		{
			return _finish;
		}

6、operator[ ]

//6、 operator[ ]

		T& operator[](size_t i)
		{
			assert(i < size());

			return _start[i];
		}


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

			return _start[i];
		}

7、size()

// 7、size()
		size_t size()
		{
			return _finish - _start;
		}

8、capacity()

// 8、capacity()

		size_t capacity()
		{
			return _end_of_storage - _start;
		}

9、reserve()

1.开辟新空间

2.拷贝数据

3.释放旧空间

4.更新数据

	// 9.reserve
		void reserve(size_t n)
		{
			size_t old_size = size();

			// 1.开辟新空间
			T* tmp = new T[n];
			// 2.拷贝数据
			for (size_t i = 0; i < old_size; i++)
			{
				tmp[i] = _start[i];
			}
			// 3.释放旧空间
			delete[] _start;
			// 4.更新数据

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

为啥要事先保存一个old_size？？？

注意：错误案例：

10、resize()

（1）当resize的大小比原来小，说明空间够，只需要修改大小即可

（2）当resize的大小比原来大，说明空间不够，同时也说明容量可能不够，要判断是否需要申请容量

		// 10、resize()
		void resize(size_t n, const T&  val= T())// 匿名函数的使用：
		{
			if (n > size())
			{
				// 扩容：
				reserve(n);

				while (_finish < _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

11、empty()

// 11、empty
		bool empty()
		{
			return _start == _finish;//起始空间是否为结束空间
		}

12、push_back()

尾插时，需要：

（1）判断增容

（2）赋值

（3）更新大小

		// 12、push_back()
		void push_back(const T& val)
		{
			// 1、判断是否需要扩容
			if (_finish == _end_of_storage)
			{
				int newcapacity = capacity()==0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			// 2.赋值：
			*_finish = val;
			// 3.更新数据：
			_finish++;

		}

13、pop_back()

尾删：

（1）判空

（2）直接更新大小

// 13、pop_back
		void pop_back()
		{
			assert(!empty());
			_finish--;
		}

14、insert()

1、先断言要插入的pos的位置要在start和finish范围之内。

2、然后再判断是否需要扩容，如果进行了扩容，那么就需要先保存要插入的pos位置到start之间的相对位置。（因为如果进行了扩容操作，那么原来的start指针就会被销毁，所以说要先保存相对位置。）

3、定义一个指针，从尾部往前遍历直到post位置的下一个元素，依次往后挪动。

// 14、insert
		void insert(iterator pos, const T& val)
		{
			// 1、先断言
			assert(pos >= _start);
			assert(pos <= _finish);

			// 2、判断是否需要扩容
			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;

				reserve(capacity() == 0 ? 4 : capacity() * 2);

				pos = _start + len;
			}
			// 3、将要插入pos的位置，后面的数据依次往后挪。
			iterator it = _finish - 1;
			while (it >= pos)
			{
				*(it + 1) = *it;
				it--;
			}
			_start[pos] = val;
			_finish++;
		}

15、erase()

1、先断言检查要删除位置pos是否在start和finish之内。

2、然后再要删除位置的下一个位置定义一个指针，然后从这个指针到结尾的位置的数据依次往前挪动覆盖数据。

3、_finish- -

// 15、erase
		void erase(iterator pos)
		{
			//1、先断言
			assert(pos >= _start);
			assert(pos <= _finish);
			//2、定义挪动数据的指针
			iterator it = pos + 1;
			while (it < _finish)
			{
				*(it-1) = *it ;
				it++;
			}
			_finish--;
		}

---

好了，今天的分享就到这里了
如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！