vector模拟实现及注意事项

STL库里面的vector定义如上

什么是vector，通俗的来讲，vector就想数组一样，vector也采用的连续存储空间来存储元素。可以像数组一样访问，它的大小是可以动态改变的，而且它的大小会被容器自动处理。

一、vector主要的一些成员函数：

1.1 构造函数

1.2 迭代器

使用迭代器来打印vector里的内容，当然还有反向迭代器等等，这里只演示一种。

1.3 容量接口

void Test2()
{
	
	int a[10] = { 0,1,2,3,4,5,6,7,8,9 };
	vector v1(a, a + sizeof(a) / sizeof(a[0]));//区间构造


	cout << v1.size() << endl;//获取数据个数
	cout << v1.capacity() << endl;//获取容量大小
	cout << v1.empty() << endl;//判断是否为空
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	v1.resize(20);//只将size改成20，默认填充0
	cout << v1.size() << endl;//获取容量大小
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	v1.resize(25, 100);//将size改成20，其余的填充成100
	cout << v1.size() << endl;//获取容量大小
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	v1.resize(5);//将size改成5，后面的多余元素舍掉
	cout << v1.size() << endl;//获取容量大小
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;


	v1.reserve(30);//仅仅将capacity改成30，size不变
	cout << v1.capacity() << endl;//获取容量大小


}

运行结果：

注意：

reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容等等代价缺陷问题。

resize在开空间的同时还会进行初始化，影响size。

1.4 元素访问接口

1.5 修改接口

void Test4()
{
	int a[10] = { 0,1,2,3,4 };
	vector v1(a, a + sizeof(a) / sizeof(a[0]));//区间构造

	v1.push_back(5);//尾插
	v1.push_back(6);
	v1.push_back(7);
	v1.push_back(8);
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	v1.insert(v1.begin() + 3, 30);//在下标为3的位置插入一个30
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	v1.assign(10, 5);//将新内容填入vector，覆盖旧的内容，并改变size的大小
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
}

运行结果：

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。
对于vector可能会导致其迭代器失效的操作有：

1. 会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。

2. 指定位置元素的删除操作--erase
erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。

我们在插入和删除时，一定要注意迭代器失效，否则会很坑。

迭代器失效的解决办法：在使用前，对迭代器重新赋值即可。

二、vector模拟实现

    template
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_end_of_shorage(nullptr)
		{}

		vector(size_t n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_shorage(nullptr)
		{
			_start = new T[n];
			for (size_t i = 0; i < n; i++)
			{
				_start[i] = val;
			}
			_finish = _start + n;
			_end_of_shorage = _start + n;
		}

		vector(int n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_shorage(nullptr)
		{
			_start = new T[n];
			for (size_t i = 0; i < n; i++)
			{
				_start[i] = val;
			}
			_finish = _start + n;
			_end_of_shorage = _start + n;
		}

		template
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_shorage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		vector(const vector& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_shorage(nullptr)
		{
			_start = new T[v.capacity()];
			for (size_t i = 0; i < v.size(); i++)
			{
				_start[i] = v._start[i];
			}

			_finish = _start + v.size();
			_end_of_shorage = _start + v.capacity();

		}

		void swap(vector& tmp)
		{
			std::swap(_start, tmp._start);
			std::swap(_finish, tmp._finish);
			std::swap(_end_of_shorage, tmp._end_of_shorage);
		}
		vector& operator=(vector tmp)
		{
			swap(tmp);
			return *this;
		}

		iterator begin()
		{
			return _start;
		}
		

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

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

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

		T& operator[](size_t n)
		{
			return *(_start + n);
		}

		const T& operator[](size_t n) const
		{
			return *(_start + n);
		}
		
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				T* tmp = new T[n];
				size_t sz = size();
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * sz);
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;

				}
				_start = tmp;
				_finish = _start + sz;
				_end_of_shorage = _start + n;
			}
		}

		void resize(size_t n, const T& val = T())
		//T()是匿名对象，如果T是内置类型，那么c++对内置类型进行了升级，也调用默认构造。
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);
				while (_finish != _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

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

		

		iterator insert(iterator pos, const T& x)
		{
			assert(pos <= _finish);
			if (_finish == _end_of_shorage)
			{
				int len = pos - _start;
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				//扩容
				reserve(newcapacity);
				pos = _start + len;//修正pos,否则会迭代器失效
			}
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*(end + 1) = x;
			_finish++;
			return pos;
		}
		iterator end()
		{
			return _finish;
		}
		bool empty()
		{
			return _finish == _start;
		}

		void pop_back()
		{
			//erase(--end());
			assert(!empty());
			--_finish;
		}

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

		void print(const vector& v)
		{
			for (auto e : v)
			{
				cout << e << " ";
			}
			cout << endl;
		}

		~vector()
		{
			delete[] _start;
			_start = _finish = _end_of_shorage = nullptr;
		}
	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_shorage;

	};

三、使用memcpy拷贝问题

1. memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中。
2. 如果拷贝的是自定义类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。

例如：

 结论：如果对象中涉及到资源管理时，千万不能使用memcpy进行对象间的拷贝，因为memcpy是浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。

解决方案：T是string这样深拷贝类，调用的是string赋值运算符重载，实现string对象的深拷贝。