STL--vector容器介绍和使用以及迭代器失效问题

一、vector的介绍

1、vector是表示可变大小的序列容器。

2、就像数组一样，vector也采用的连续存储空间来存储元素。也就意味着可以采用下标对vector的元素进行访问和数组一样高效。但是又不像数组，它的大小可以动态改变的，而且它的大小会被容器自动处理。

3、本质讲，vector使用动态分配数组来存储它的元素。当新元素插入的时候，为了增加存储空间这个数组需要被重新分配。其做法是分配新的数组，然后将全部元素移到新的数组中。就时间而言，这是一个相对代价较高的任务，但是vector并不会每次都重新分配大小。vector有自己的内存分配策略。

4、vector它以两个迭代器start和finish分别指向配置得来的连续空间中目前已被使用的范围，以迭代器end_of_storage指向整块连续空间(含备用空间)的尾端：

template<class T,class Alloc=alloc>
class vector{
     
...
protected:
	iterator start;				//表示目前使用空间的头
	iterator end;				//表示目前使用空间的尾
	iterator end_of_storage;	//表示目前可用空间的尾

}

5、为了更好的管理存储空间，所以vector占用了更多的空间，并且以一种有效的方式动态增长。

6、与其它动态序列容器相比(deque、list、forward_list) ，vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其他不在末尾的删除和插入操作，效率更低。比起lists和forward_lists统一的迭代器和引用更好。

二、vector的使用

2.1、vector的定义

构造函数说明	接口说明
vector()重点	无参构造
vector（size_type n, const value_type& val = value_type()）	构造并初始化n个val
vector (const vector& x) 重点	拷贝构造
vector(InputIterator first,InputIterator last)	使用迭代器进行初始化构造

#include
using namespace std;

int main() {
     
	//空容器
	vector<int> one;
	//包含10个int元素值为8
	vector<int> two(10, 8);
	
	//three 的拷贝
	vector<int> fouth(two);
	//迭代器初始化
	int arr[] = {
     1,2,3,6};
	vector<int> five(arr,arr+sizeof(arr)/sizeof(arr[0]));
	
	cout << "five content are: " << endl;
	for (auto it = five.begin(); it != five.end(); ++it) {
     
		cout << *it << ' ';
	}
	cout << endl;
	return 0;
}

2.2、vector 迭代器的使用

迭代器遵循前闭后开的规则，[begin(),end()) ,end()迭代器指向的是最后一个元素的下一个位置，所以对end解引用是未定义的。

iterator的使用	接口说明
begin+end 重点	获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置 的iterator/const_iterator
rbegin+rend	获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的 reverse_iterator

#include
#include
using namespace std;

void PrintVector(const vector<int>&vec ) {
     
	vector<int>::const_iterator cit = vec.begin();
	while (cit != vec.cend()) {
     
		cout << *cit << " ";
		//const 迭代器不修改元素
		//*cit *= 2;
	}
	cout << endl;
}
int main() {
     
	vector<int> v{
     1,2,3,4};
	//使用迭代器遍历打印并修改
	vector<int>::iterator it = v.begin();
	while (it != v.end()) {
     
		*it *= 2;
		cout << *it << " ";
		++it;
	}
	cout << endl;
	//使用反向迭代器进行打印
	vector<int>::reverse_iterator rit = v.rbegin();
	while (rit != v.rend()) {
     
		cout << *it << " ";
		++it;
	}
	cout << endl;
	PrintVector(v);
	return 0;
}

2.3、vector 空间增长问题

容量空间接口	接口说明
size	获取数据个数
capacity	获取容量大小
empty	判断是否为空
resize	改变vector的size
reserve	改变vector的capacity

注意：

• 1、capacity的代码在vs和g++下分别运行会发现，vs下capacity是按照1.5倍增长的，g++是按照2倍增长的。不要固化的认为，顺序表增容就是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本的STL，g++是SGI的STL版本。
• 2、reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解增容的代价缺陷问题。影响的是capacity的大小。
• 3、resize在开空间的同时还会进行初始化，影响的是size的大小。

2.3.1、vector::capacity 测试

#include
#include
using namespace std;

int main() {
     
	vector<int> vec;
	size_t sz = vec.capacity();
	cout << "making vec grow.." << endl;
	for (int i = 0; i < 100; i++) {
     
		vec.push_back(i);
		if (sz != vec.capacity()) {
     
			sz = vec.capacity();
			cout << "capacity changed: " << sz << endl;
		}
	}
	return 0;
}

vs下capacity的变化：

g++下capacity的变化：

2.3.2、vector::capacity测试

#include
#include

using namespace std;

void test() {
     
	vector<int> vec;
	size_t sz = vec.capacity();
	vec.reserve(20);
	for (int i = 0; i < 20; i++) {
     
		vec.push_back(i);
	}
	cout << "pop_back() elements:" << endl;
	for (int i = 0; i < 15; i++) {
     
		vec.pop_back();
		cout << "size=" << vec.size() << endl;
		cout << "capacity=" << vec.capacity() << endl;
	}
}

测试结果：

我们可以看到，当我们pop_back() 元素的时候，capacity没有变化。

问题：我们不能调用vector的reserve方法，这时怎么让vector的capacity变为0？

#include
#include

using namespace std;

int test() {
     
	vector<int> vec;
	size_t sz = vec.capacity();
	vec.reserve(15);
	for (int i = 0; i < 15; i++) {
     
		vec.push_back(i);
	}
	cout << "size=" << vec.size() << endl;
	cout << "capacity=" << vec.capacity() << endl;
	//我们可以用一个临时对象，然后让临时对象和vec交换，那么vec的capacity就变为0了，这时temp出作用域，vector析构，最终达到目的。
	{
     
		vector<int> temp;
		temp.swap(vec);
	}

	cout << "size=" << vec.size() << endl;
	cout << "capacity=" << vec.capacity() << endl;
}

2.3.3、vector::resize 测试

#include 
#include

using namespace std;
int main()
{
     
	std::vector<int> myvector;
	
	// set some initial content:
	for (int i = 1; i < 10; i++)
		myvector.push_back(i);
		
	myvector.resize(5);			// 1 2 3 4 5
	myvector.resize(8, 100); 	//1 2 3 4 5 100 100 100
	myvector.resize(12);		//1 2 3 4 5 100 100 100 0 0 0 0
	std::cout << "myvector contains:";
	for (int i = 0; i < myvector.size(); i++)
		cout << ' ' << myvector[i];
	cout << endl;
	return 0;
}

2.4、vector 增删查改

vector的增删查改	接口说明
push_back 重点	尾插
pop_back 重点	尾删
find	查找。（注意这个是算法模块的实现，不是vector的成员接口）
void insert (iterator position, size_type n, const value_type& val)	在position之前插入val，返回新插入第一个元素的迭代器
iterator erase (iterator position);	删除position位置的数据，返回删除最后一个元素的下一个位置的迭代器
swap	交换两个vector的数据空间
operator[] 重点	像数组一样访问

2.4.1、vector::insert 、erase和find测试

#include
#include
#include //find算法所包含的头文件

using namespace std;

int main() {
     
	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);
	
	v.insert(pos, 30);	//1 2 30 3 4
	vector<int>::iterator it = v.begin();
	while (it != v.end()) {
     		//1,2,30,3,4
		cout << *it << " ";
		++it;
	}
	cout << endl;

	pos = find(v.begin(), v.end(), 3);
	// 删除pos位置的数据
	v.erase(pos);
	it = v.begin();
	while (it != v.end()) {
     	//1,2,30,4
		cout << *it << " ";
		++it;
	}
	cout << endl;
	
	return 0;
}

2.4.2、vector遍历和swap函数的使用

#include
#include

using namespace std;

int main() {
     

	int a[] = {
      1, 2, 3, 4 };
	vector<int> v(a, a + sizeof(a) / sizeof(int));
	
	// 通过[]读写第0个位置。
	v[0] = 10;
	cout << v[0] << endl;
	// 通过[i]的方式遍历vector
	for (size_t i = 0; i < v.size(); ++i)
		cout << v[i] << " ";
	cout << endl;

	vector<int> swapv;
	swapv.swap(v);
	// C++11支持的新式范围for遍历
	cout << "v data:";
	for (auto x : v)
		cout << x << " ";
	cout << endl;
	cout << "swapv data:";
	for (auto x : swapv)
		cout << x << " ";
	cout << endl;
}

三、vector的迭代器失效

3.1、什么是迭代器

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行封装，对于vector的迭代器就是原生态的指针T * 。

3.2、迭代器失效

我们知道vector增加的元素超过当前容量时，那么会经历“重新配置、元素移动、释放原空间”等过程，如果vector的继续使用指向原来空间的迭代器，然而原来的空间已经被释放了，如果继续使用已经失效的迭代器，那么可能造成程序的崩溃。

3.3、导致迭代器失效的操作

3.3.1、可能导致迭代器失效的方法

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

#include 
using namespace std;
#include 
int main()
{
     
	vector<int> v{
     1,2,3,4,5,6};
	auto it = v.begin();
	// 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
	// v.resize(100, 8);
	// reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
	// v.reserve(100);
	// 插入元素期间，可能会引起扩容，而导致原空间被释放
	// v.insert(v.begin(), 0);
	// v.push_back(8);
	// 给vector重新赋值，可能会引起底层容量改变
	v.assign(100, 8);
	
	/*
	出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
	而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的
	空间，而引起代码运行时崩溃。
	*/
	
	while(it != v.end())
	{
     
	cout<< *it << " " ;
	++it;
	}
	cout<<endl;
	return 0;
}

3.3.2、指定位置元素的删除操作 erase

#include
#include
using namespace std;

int main(){
     
	int a[] = {
      1, 2, 3, 4 };
	vector<int> v(a, a + sizeof(a) / sizeof(int));
	// 使用find查找3所在位置的iterator
	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就认为该位置迭代器失效了。

请看以下代码删除vector容器中的偶数，以下那段代码是正确的？

void test1()
{
     
	vector<int> v{
      1, 2, 3, 4 };
	auto it = v.begin();
	while (it != v.end())
	{
     
		if (*it % 2 == 0)
			v.erase(it);
		++it;
	}
	
}

void test2()
{
     
	vector<int> v{
      1, 2, 3, 4 };
	auto it = v.begin();
	while (it != v.end())
	{
     
		if (*it % 2 == 0)
			it = v.erase(it);
		else
			++it;
	}
}

//test2是正确的，因为erase函数的返回值是删除最后一个元素的下一个位置的元素。
//对于test1接着用删除后的迭代器，造成迭代器失效问题，所以test1是错误的。

3.4、解决迭代器失效的方法

在使用迭代器前，对迭代器重新赋值。