vector的介绍以及使用方式

2.构造函数

这里的接口很多使用方式都是和我们的string都是类似的，但是对于我们的迭代器初始化，我们并没有接触过，这里我给大家看看该具体的样子：

对于迭代器的初始化这里的InputIterator指的是一个模板类型，所以这里的迭代器可以是各个类型的。

测试代码：

#include<iostream>
#include<vector>//使用记得包文件
using namespace std;
int main()
{
	//需实例化模板
	//无参构造
	vector<int> v1();
	//构造并初始化n个val
	vector<int> v2(10, 1);
	//拷贝构造
	vector<int> v3(v2);
	//迭代器构造
	int a[] = { 10,9,8,7,6,5,4,3,2,1 };
	vector<int>v4(a, a + 10);
	return 0;
}

这里大家可以看到我们迭代器版本初始化时使用了我们的数组进行初始化，这是由于数组我们可以看做是一个天然的迭代器，自然我们可以使用我们的数组首地址和首地址+某个值进行初始vector。

这里由于我们的vector没有我们的流提取操作符的重载，因此这里我们给大家打开我们的监视窗口，来看一下我们底层的存储情况。

3.迭代器

这里给大家简单看看一下我们正向迭代器begin（）和end（）的指向，以及我们正向迭代器和我们反向迭代器的对应关系：

测试代码：

#include<iostream>
#include<vector>//使用记得包文件
using namespace std;
int main()
{
	int a[] = { 10,9,8,7,6,5,4,3,2,1 };
	vector<int> v1(a, a + 10);
	//范围for验证
	for (auto& e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
	//正向迭代器验证
	vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	//反向迭代器验证
	vector<int>::reverse_iterator it1 = v1.rbegin();
	while (it1 != v1.rend())
	{
		cout << *it1 << " ";
		it1++;
	}
	return 0;
}

结果如下：

4.vector空间增长问题

capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL。

reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。resize在开空间的同时还会进行初始化，影响size

对于我们vs和我们g++空间增长机制，这里我们使用一串代码给大家验证一下：

void text_space_expand()
{
	size_t cp = 0;
	vector<int> v1;
	cp = v1.capacity();
	for (int i = 0; i < 1000; i++)
	{
		v1.push_back(i);
		if (cp != v1.capacity())
		{
			cp = v1.capacity();
			cout << "capacity changed:" << cp << endl;
		}
	}

}

vs平台下运行结果：

g++运行结果：

这里大家就可以清楚的看到，我们的capacityvs下是按1.5倍增长的，g++是按2倍增长的。

那么这里就简单的给大家演示一下这几个接口的用法：

#include<iostream>
#include<vector>//使用记得包文件
using namespace std;
int main()
{
	vector<int> v1(10, 1);
	cout << "有效数据个数:" << v1.size()<<endl;
	cout << "空间大小:" << v1.capacity() << endl;
	cout << "是否为空:" << v1.empty() << endl;

	v1.clear();
	cout << "有效数据个数:" << v1.size() << endl;
	cout << "空间大小:" << v1.capacity() << endl;
	cout << "是否为空:" << v1.empty() << endl;

	v1.resize(9, 1);
	v1.reserve(100);
	cout << "有效数据个数:" << v1.size() << endl;
	cout << "空间大小:" << v1.capacity() << endl;
	cout << "是否为空:" << v1.empty() << endl;
	return 0;
}

结果如下：

5.vector的增删改查

我们的vector本身并没有是实现我们的find，我们这里的find时属于算法模块的，也就是

这里我们的调用方式是，传入一个迭代器区间，然后在这个区间内查找我们的val，这里返回的也是这个值的迭代器。

对于我们的insert这里一共有三个版本：

第一个是在我们pos迭代器位置前插入val，一个是在pos迭代器位置前插入n个val，第三个是在pos位置前插入一段迭代器区间(不过由于效率问题，我们这里并不经常使用)

对于erase我们这里也有两个版本：

第一个是删除pos迭代器的值，一个是删除一段迭代器区间，注意这里返回值是我们的迭代器，这里和我们的迭代器失效有关

测试代码如下：

#include<iostream>
#include<vector>//使用记得包文件
#include<algorithm>//算法库头文件
using namespace std;
int main()
{
	vector<int> v1;
	//尾插
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	//方括号读取修改数据
	for (int i = 0; i < v1.size(); i++)
	{
		v1[i]++;
		cout << v1[i] << " ";
	}
	cout << endl;
	//尾删
	v1.pop_back();
	for (auto& e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
	//查找
	auto it = find(v1.begin(), v1.end(), 4);
	cout << *it << endl;
	//删除具体某个值
	v1.erase(it);
	for (auto& e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
	//在某个具体位置插入
	v1.insert(v1.begin() + 2, 20);
	v1.insert(v1.begin() + 2,4, 10);
	for (auto& e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
	vector<int> v2(10,1);
	cout << "交换前v1的值:";
	for (auto& e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << "交换前v2的值:";
	for (auto& e : v2)
	{
		cout << e << " ";
	}
	cout << endl;
	v1.swap(v2);
	cout << "交换后v1的值:";
	for (auto& e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << "交换后v2的值:";
	for (auto& e : v2)
	{
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

结果如下：

6.vector迭代器失效问题

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

那么对于vector可能会导致其迭代器失效的操作有：

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

#include <iostream>
using namespace std;
#include <vector>
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迭代器操作时，实际操作的是一块已经被释放的
空间，而引起代码运行时崩溃。
解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
赋值即可，也就是让我们的it重新指向新空间
*/
while(it != v.end())
{
cout<< *it << " " ;
++it;
}
cout<<endl;
return 0;
}

2. 指定位置元素的删除操作--erase

#include <iostream>
using namespace std;
#include <vector>
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就认为该位置迭代器失效了。

既然我们erase的存在着迭代器失效的问题，那么我们库中是如何解决此类问题的呢？

首先需要注意我们erase的返回值就是我们删除后下一个位置的迭代器，因此重新接收后，就不会导致我们的迭代器失效。

以下代码的功能是删除vector中所有的偶数，请问那个代码是正确的，为什么？

#include <iostream>
using namespace std;
#include <vector>
//程序一
int main()
{
vector<int> v{ 1, 2, 3, 4 };
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
v.erase(it);
++it;
}
return 0;
}
//程序二
int main()
{
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;
}
return 0;
}

首先通过我们上面的讲解，我们的程序二很明显是错误，那么我们程序一在能运行的情况下，该是否会发生迭代器失效呢？这里我给大家分析一下：

对于程序二，我们每次删除后都会接受erase删除下一个值，不会出现迭代器失效的情况。

3. 注意：Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。

实际上我们的在删除偶数时，我们程序一的代码在vs下是不能运行的，因为vs对这个进行的是强制检查，无论我们的删除后我们的迭代器指向那里都会崩溃，只有重新接收后才不会影响程序运行

这里就给大家举例几个g++下的例子：

例一：

// 1. 扩容之后，迭代器已经失效了，程序虽然可以运行，但是运行结果已经不对了
int main()
{
vector<int> v{1,2,3,4,5};
for(size_t i = 0; i < v.size(); ++i)
cout << v[i] << " ";
cout << endl;
auto it = v.begin();
cout << "扩容之前，vector的容量为: " << v.capacity() << endl;
// 通过reserve将底层空间设置为100，目的是为了让vector的迭代器失效
v.reserve(100);
cout << "扩容之后，vector的容量为: " << v.capacity() << endl;
// 经过上述reserve之后，it迭代器肯定会失效，在vs下程序就直接崩溃了，但是linux下不会
// 虽然可能运行，但是输出的结果是不对的
while(it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
return 0;
}

运行结果：

程序输出：1 2 3 4 5
扩容之前，vector的容量为: 5
扩容之后，vector的容量为: 100
0 2 3 4 5 409 1 2 3 4 5

这里很明显可以看出我们迭代器访问旧空间的值出现的是随机的。

例二：

// 2. erase删除任意位置代码后，linux下迭代器并没有失效
// 因为空间还是原来的空间，后序元素往前搬移了，it的位置还是有效的
#include <vector>
#include <algorithm>
int main()
{
vector<int> v{1,2,3,4,5};
vector<int>::iterator it = find(v.begin(), v.end(), 3);
v.erase(it)
cout << *it << endl;
while(it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
return 0;
}

运行结果：

程序可以正常运行，并打印：
4
4 5

这里我们看到例二是正常的，那么我们看下面一个例子

例三（就是之前的删除偶数的程序一）：

// 3: erase删除的迭代器如果是最后一个元素，删除之后it已经超过end
// 此时迭代器是无效的，++it导致程序崩溃
int main()
{
vector<int> v{1,2,3,4,5};
// vector<int> v{1,2,3,4,5,6};
auto it = v.begin();
while(it != v.end())
{
if(*it % 2 == 0)
v.erase(it);
++it;
}
for(auto e : v)
cout << e << " ";
cout << endl;
return 0;
}

对于例子三我们这里提供了两个版本的数据，一个是要删除最后一个元素，一个是不用删除最后一个元素，那么两组数据运行的结果是：

数据一：

运行正常，打印结果为：

1 3 5

数据二：

程序崩溃：

Segmentation fault

4.与vector类似，string在插入+扩容操作+erase之后，迭代器也会失效

#include <string>
void TestString()
{
string s("hello");
auto it = s.begin();
// 放开之后代码会崩溃，因为resize到20会string会进行扩容
// 扩容之后，it指向之前旧空间已经被释放了，该迭代器就失效了
// 后序打印时，再访问it指向的空间程序就会崩溃
//s.resize(20, '!');
while (it != s.end())
{
cout << *it;
++it;
}
cout << endl;
it = s.begin();
while (it != s.end())
{
it = s.erase(it);
// 按照下面方式写，运行时程序会崩溃，因为erase(it)之后
// it位置的迭代器就失效了
// s.erase(it);
++it;
}
}

对于迭代器失效问题，这是我们在平时使用过程中需要注意的，解决方式就是在失效后，我们需要重新赋值就可以解决了。

总结

对于vector常用接口的介绍，基本已经到这里了，其他的接口就需要靠大家查阅文档，或者使用中去不断学习。