【C++ STL】领略vector之美,熟练掌握vector的使用

一.vector容器简单介绍

1. vector是表示可变大小数组的序列容器。
2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
6. 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好.

与传统C语言风格的数组相比,vector支持自动扩容,而且C语言数组对于越界访问的检查是一种抽查机制,有可能检查不出来的,而vector中是以assert的方式暴力检查,只要访问就报错.更加的安全

vector的优缺点:
1.优点:vector是一种顺序表,它随机访问效率高.
2.缺点:vector在尾部插入删除还可以,但是在头部插入删除需要挪动后面的数据,时间复杂度为O(N),效率相对较低.

因此,一般而言,链表(list)和顺序表(vector)是相辅相成的两种数据结构,它们优缺点正好相反,如果需要随机访问速度快就使用vector,需要插入删除效率高就用list.

二.vector的构造函数

STL库中依旧提供了多种重载函数用来构造一个vector对象.

函数名称	功能说明
vector()(重点)	无参构造
vector（size_type n, const value_type& val = value_type()）	构造并初始化成n个val
vector (const vector& x); （重点）	拷贝构造
vector (InputIterator first, InputIterator last);(也挺好用)	迭代器区间初始化
vector (initializer_list<value_type> il)	C++11之后支持用initializer_list来初始化

这里还要注意:vector是一个类模板,创建对象时需要显示实例化,
例如:vector<T>

代码示例:

int main()
{
	//默认构造
	vector<int> v1;

	//n个val构造
	vector<int> v2(10, 1);

	//拷贝构造
	vector<int> v3(v2);   //也可以写成vector<int> v3 = v2;

	//迭代器区间初始化
	int a[10] = { 0,1,2,3,4,5,6,7,8,9 };
	vector<int> v4(a, a + 10);

	//initializer_list初始化
	initializer_list<int> il = { 0,1,2,3,4,5,6,7,8,9 };
	vector<int> v5(il);  //也可以写成  vector<int> v5({ 0,1,2,3,4,5,6,7,8,9 });或者vector<int> v5{ 0,1,2,3,4,5,6,7,8,9 };

	cout << "默认构造:";
	for (const auto& e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	cout << "n个val构造:";
	for (const auto& e : v2)
	{
		cout << e << " ";
	}
	cout << endl;

	cout << "拷贝构造:";
	for (const auto& e : v3)
	{
		cout << e << " ";
	}
	cout << endl;

	cout << "迭代器区间初始化:";
	for (const auto& e : v4)
	{
		cout << e << " ";
	}
	cout << endl;

	cout << "initializer_list初始化:";
	for (const auto& e : v5)
	{
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

输出结果:

默认构造:
n个val构造:1 1 1 1 1 1 1 1 1 1
拷贝构造:1 1 1 1 1 1 1 1 1 1
迭代器区间初始化:0 1 2 3 4 5 6 7 8 9
initializer_list初始化:0 1 2 3 4 5 6 7 8 9

如果有需要的小伙伴可以去官方文档再查看一下:vector

三.vector中与容量和大小相关操作

3.1接口函数说明

函数名称	功能说明
size()	获取数据个数
capacity()	获取容量大小
empty()	判断是否为空
resize()(重点)	改变vector的
reserve()(重点)	改变vector的capacity
shrink_to_fit	收缩capacity使其适应size

代码示例:

int main()
{
	vector<int> v1{1,2, 3, 4, 5, 6, 7, 8, 9};
	cout << "size:" << v1.size()<<endl;
	cout << "capacity:" << v1.capacity() << endl;
	
	v1.resize(20);
	cout << "resize后:" << v1.size() << endl;
	cout << "capacity:" << v1.capacity() << endl;
	
	v1.reserve(100);
	cout << "size:" << v1.size() << endl;
	cout << "reserve:" << v1.capacity() << endl;
	
	v1.shrink_to_fit();
	cout << "size:" << v1.size() << endl;
	cout << "shrink_to_fit:" << v1.capacity() << endl;
	return 0;
}

输出结果:

size:9
capacity:9
resize后:20
capacity:20
size:20
reserve:100
size:20
shrink_to_fit:20

3.2使用时的性能优化

当vector容量满之后再插入数据,就会自动扩容,通常的过程是申请一块更大的空间,将数据拷贝过去之后,释放旧空间.如果频繁扩容,在效率上会比较低下.
因此我们如果知道共有多少个数据,就可以resize提前开好足够的空间,避免频繁扩容.

四.vector中的元素访问与修改

1.元素访问方法:

元素访问方法	功能说明
operator[]	通过下标访问vector,内部通过assert对下标进行了严格检查
at()	也是通过下标访问,内部通过抛出异常来报错
front()	返回第一个元素
back()	返回最后一个元素
data()	返回指向数组首元素的指针

代码示例:

int main()
{
	vector<int> v1{ 1,2,3,4,5,6,7,8,9 };
	
	for (size_t i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}
	cout << endl;
	
	try {
		cout << v1.at(10);  // 越界访问
	}
	catch (out_of_range& e) 
	{
		cout << "Exception: " << e.what() << endl;
	}//异常捕获
	
	cout << "front:" << v1.front() << endl;
	cout << "back:" << v1.back() << endl;
	return 0;
}

输出结果:

1 2 3 4 5 6 7 8 9
Exception: invalid vector subscript
front:1
back:9

2.元素修改方法
可以通过operator[]和at来直接进行修改.


这两个函数的返回值是引用,因此直接通过返回值修改数据即可.

五.vector迭代器与遍历

5.1迭代器

vector中有许多类型的迭代器,便于我们遍历与访问元素.

迭代器	功能说明
begin()	返回指向第一个元素的迭代器
end()	返回指向最后元素的下一个位置的迭代器
rbegin()	返回指向最后一个元素的反向迭代器
rend()	返回指向第一个元素的前一个位置的迭代器

代码示例:

int main()
{
	vector<int> v1{ 1,2,3,4,5,6,7,8,9 };
	
	//正向迭代器遍历
	vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	
	//反向迭代器遍历
	vector<int>::reverse_iterator rit = v1.rbegin();
	while (rit != v1.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
	return 0;
}

输出结果:

1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1

5.2迭代器失效问题

迭代器失效问题的本质:就是迭代器指向的空间被销毁了或者不指向有效的数据了,这时失效的迭代器就类似于野指针一样,如果再用它来访问元素,就会导致程序崩溃.

对于vector可能会导致其迭代器失效的操作有：
1. 会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。
2. 指定位置元素的删除操作–erase.

5.2.1 扩容导致的迭代器失效问题

为了引出这个问题,我们接下来看一段代码.
代码示例:

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重新
	赋值即可。
	 */
	 while(it != v.end())
	 {
	 cout<< *it << " " ;
	 ++it;
	 }
	 cout<<endl;
	 return 0;
}

观察文档,我们会发现,通过迭代器来确定位置的insert重载函数,都会返回一个迭代器,这个迭代器是指向新插入的第一个元素的迭代器。

因此,我们在使用insert插入是时要及时更新迭代器!!!
代码示例:

int main()
{
	vector<int> v1{ 1,2,3 };
	auto it = v1.begin()+2;
	cout << *it << endl;
	//更新失效的迭代器
	it = v1.insert(it, 4);
	
	cout << *it << endl;
	return 0;
}

输出结果:

3
4

5.2.2删除导致的迭代器失效问题

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

以下代码的功能是删除vector中所有的偶数.

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;
}

还是要注意更新迭代器!

希望对你有所帮助,感谢观看!