C++中vector的用法、vector模拟实现、vector中迭代器失效详解！

1. vector用法

vector是可变大小数组的序列容器

1.1 vector的定义

vector() 无参构造函数
vector(size_t n,const T& value = T()) 构造并数组初始化n个value
vector(const vector< T >& v) 拷贝构造
vector(InputIterator first, InputIterator last) 用迭代器构造

std::vector<int> a;    //构造一个空数组
std::vector<int> b(4,100); //构造一个数组，初始化为4个100
std::vector<int> c(b); //用b拷贝构造d
std::vector<int> d(b.begin(),b.end()); //b的迭代器构造d
int arr[] = {16,2,77,29};
std::vector<int> e(myints, arr + sizeof(arr) / sizeof(int));

1.2 vector迭代器的使用

begin() 返回vector对象起始位置的迭代器
end() 返回vector对象最后一个元素下一个位置的迭代器，用来标志结束
cbegin() 返回用const修饰的vector对象的起始位置迭代器
cend() 返回用const修饰的vector对象最后一个元素下一个位置的迭代器
rbegin() 返回反向第一个位置的迭代器，rend()、crbegin()、crend()原理相同

vector<int> v(4,1);
// 使用迭代器进行遍历打印
vector<int>::iterator it = v.begin();
while (it != v.end())
{
	cout << *it << " ";
	++it;
}
cout << endl;
//使用迭代器进行修改
it = begin();
while(it != end())
{
	*it++ = 2;
}

1.3 vector空间相关函数

size() 返回vector对象实际元素个数
capacity() 返回vector对象分配到的空间大小
reserve() 扩容，改变vector对象capacity()大小
resize() 改变vector对象size()大小
empty() 判断是否为空

//resize()
	std::vector<int> v(6, 7);
	v.resize(3);              //将空间缩小到3
	v.resize(10, 8);          //将空间扩大为10，多余的空间用8填充
	v.resize(15);             //将空间扩大到15
	for (auto e : v)
	{
		std::cout << e << " ";
	}
	std::cout << std::endl;

//reserve()
	std::vector<int> v;
	v.reserve(100);                   //给bar分配100个空间
	std::cout << v.capacity() << std::endl;

1.3 vector增删改查

push_back() 尾插数据
pop_back() 尾删数据
insert() 在任意位置插入数据
erase() 任意位置删除数据
swap() 交换两个对象的空间
operator[] 像数组一样访问和修改

    std::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	Print(v);
	v.insert(v.begin() + 2, 88);  //第三个位置插入88
	Print(v);
	v.pop_back();             //尾删
	Print(v);
	v.erase(v.begin() + 1);   //删除第二个位置
	Print(v);
	std::vector<int> v1(8 , 1);
	v.swap(v1);     //交换v和v1的空间
	Print(v);
	for (size_t i = 0; i < v.size(); ++i)   //用[]来访问并修改vector对象的空间
	{
		v[i] = 2;
	}
	Print(v);

2. 模拟实现vector

namespace zhy{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;             //vector的迭代器是T类型的原生指针
		typedef const T* const_iterator; //const对象可以使用的迭代器
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
		}
		vector(int n, const T& value = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n);
			while (n)
			{
				push_back(value);
				n--;
			}
		}
		template<class Iterator>                         //用任意容器的迭代器来初始化vector
		vector(Iterator first, Iterator last)
		{
			reserve(last - first);          //先增容
			while (first<last)
			{
				push_back(*first);
				first++;
			}
		}
		vector(const vector<T>& v)                      //拷贝构造
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(v.capacity());
			iterator begin = _start;
			const_iterator it = v.cbegin();
			while (it < v.cend())
			{
				*begin = *it;
				begin++;
				it++;
			}
			_finish = _start + v.size();
		}
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldsize = size();
				T* temp = new T[n];
				if (_start)
				{
					//memcpy(temp, _start, sizeof(*T)*size());   memcpy是二进制格式拷贝，是将一段内存空间中的内容直接拷贝到
					//目标空间中（浅拷贝），对涉及到内存资源管理的自定义类型就会出错，只能用来拷贝内置类型。
					//例：原空间中存放的是string类型的数据，用memcpy拷贝时，只使新空间指向了旧的string对象，当旧空间释放后，新空间
					//中就都是野指针。
					for (size_t i = 0; i < size(); i++)
					{
						temp[i] = _start[i];
					}
				}
				delete[] _start;         //释放原有空间，防止内存泄漏
				_start = temp;
				_finish = _start + oldsize;
				_endofstorage = _start + n;
			}
		}
		void resize(size_t x, const T& value = T())
		{
			if (x > capacity())   //内存不够先增容
			{
				reserve(x);
			}
			if (x <= size()) 
			{
				_finish = _start + x;
			}
			else
			{
				iterator begin = _finish;
				_finish = _start + x;
				while (begin != _finish)
				{
					*begin = value;
					begin++;
				}
			}
		}
		void push_back(const T& value)
		{
			insert(end(), value);        //尾插
		}
		void pop_back()
		{
			erase(--end());              //尾删
		}
		iterator insert(iterator pos,const T& x)
		{
			if (_finish == _endofstorage)    //空间满了需要增容
			{
				size_t p = pos - _start;     //记录迭代器的位置
				reserve(capacity() * 2 + 1);   //+1是为了防止capacity为0，增容失败
				pos = _start + p;           //给迭代器重新赋值，防止迭代器失效
			}
			iterator end = _finish;
			while (end > pos)             //从pos位置向后移动，将pos位置空出来
			{
				*end = *(end - 1);
				end--;
			}
			*pos = x;                    //把x填到pos位置
			_finish++;
			return pos;                  //返回迭代器，在外面使用该迭代器就得重新赋值，防止迭代器失效
		}
		iterator erase(iterator pos)
		{
			iterator i = pos + 1;
			while (i < _finish)         //从pos的下一个位置向前移动，覆盖pos位置
			{
				*(i - 1) = *i;
				i++;
			}
			_finish--;
			return pos;
		}
		void swap(vector<T>& temp)
		{
			std::swap(_start, temp._start);
			std::swap(_finish, temp._finish);
			std::swap(_endofstorage, temp._endofstorage);
		}
		const_iterator cbegin() const          //const对象调用
		{
			return _start;
		}
		const_iterator cend() const
		{
			return _finish;
		}
		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}
		size_t capacity() const                     //加const的原因：const对象和非const对象都可以调用
		{
			return _endofstorage - _start;
		}
		size_t size() const
		{
			return _finish - _start;
		}
		bool empty()
		{
			if (size() == 0)
				return true;
			else
				return false;
		}
		T& operator[](size_t n)
		{
			assert(n < size());
			return _start[n];
		}
		const T& operator[](size_t n) const
		{
			assert(n < size());
			return _start[n];
		}
		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}
		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _endofstorage = nullptr;
			}
		}

	private:
		iterator _start;              //指向vector有效数据的开始
		iterator _finish;             //指向vector有效数据的结尾的下一个位置
		iterator _endofstorage;       //指向vector实际占有内存的尾
	};
}

3. 迭代器失效问题

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

3.1 增容引起的迭代器失效

有关修改内存的操作都可能会引起迭代器失效：reserve、resize、insert、push_back等。

	std::vector<int> v(5, 1);
	auto it = v.begin();
	v.resize(100, 2);    //内部增容后，v新开辟了一块空间，it还指向的原来的空间，导致迭代器失效
	v.reserve(100);      //操作期间可能会引起底层容量改变,原空间释放，迭代器失效
	v.insert(v.begin(), 1);  //插入可能引起增容，原空间释放，迭代器失效
	v.push_back(8);	

出错原因：以上操作，都有可能会导致vector扩容，vector原来的旧空间被释放掉，而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的空间，而引起代码运行时崩溃。
解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新赋值即可。

3.2 删除元素导致迭代器失效

int a[] = { 1, 2, 3, 4 };
vector<int> v(a, a + sizeof(a) / sizeof(int));
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
// 删除pos位置的数据，导致pos迭代器失效。
v.erase(pos);
cout << *pos << endl; // 此处会导致非法访问
return 0;

出错原因：erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了，程序崩溃。
注：Linux用g++编译时，删除不是最后一个位置的元素时不认为迭代器失效，程序可以正常运行
解决方法：删除元素后，在下次使用前对迭代器进行重新赋值即可。