vector如何避免多次不必要的扩容带来的性能损失（reserve函数的调用）

vector如何避免不必要的扩容

1、vector数据结构性质

vector占用一块连续分配的内存，一种可以存储任意类型的动态数组，与array不同的地方就是：数组是静态分配空间，一旦分配了空间的大小，就不可再改变了；而vector是动态分配空间，随着元素的不断插入，它会按照自身的一套机制不断扩充自身的容量。

vector数据结构如下，通过三个迭代器start, finish, end_of_storage的系列public接口，可很好地完成数据存储、溢出判断(iter >= iv.end())、大小、容量(容量与大小不等，以免不断申请空间耗费资源)、重载操作符[]、判空、最前元素、最后元素等等。

  	iterator start;               // 表示目前使用空间的头
    iterator finish;              // 表示目前使用空间的尾
    iterator end_of_storage;      // 表示实际分配内存空间的尾

扩容条件

size==capacity

 - size:实际所包含的元素个数 
 - capacity:容器的容量,指的是在不分配更多内存的情况下，容器可以保存的最多元素个数

vector 容器扩容的整个过程，大致分为以下 4 个步骤：

• 1、分配一块大小是当前 vector 容量几倍的新存储空间。注意，多数 STL 版本中的 vector 容器，其容器都会以 2
  的倍数增长，也就是说，每次 vector 容器扩容，它们的容量都会提高到之前的 2 倍；
• 2、将 vector 容器存储的所有元素，依照原有次序从旧的存储空间复制到新的存储空间中；
• 3、析构掉旧存储空间中存储的所有元素；
• 4、释放旧的存储空间。

通过以上分析不难看出，vector 容器的扩容过程是非常耗时的，并且当容器进行扩容后，之前和该容器相关的所有指针、迭代器以及引用都会失效。因此在使用 vector 容器过程中，我们应尽量避免执行不必要的扩容操作。

2、push_back后iterator失效程序崩溃的原因

在使用push_back对vector进行构造的时候，vector的容量capacity(与size有区别)会根据压入元素的数量进行内存的自动重新分配，这时候iterator会因为vector存储空间的变化而失效，需要注意iterator的有效性，以免iterator指向未知的内存空间导致程序异常。

应用举例

//code2

#include <iostream>
#include <vector>
using namespace std;

#define MAX_NUM 9

int main(){
	vector<int> vecInt;
	
	for(int i = 0; i != MAX_NUM; i++){
		vecInt.push_back(i);
	}

	vector<int>::iterator iter = vecInt.begin();
	cout << "the 1st element: " << *iter << endl;
	
	vecInt.push_back(123);
	
	while(iter != vecInt.end()){
		cout << *iter << " ";
		iter++;
	}
	
	return 0;
}

在用for进行vector的push_back之后，初始化了一个iterator指向vecInt的begin位置，并打印验证。之后再用push_back在vector的末尾添加了一个元素123，这时候用iter来遍历vecInt。

下面对MAX_NUM进行修改，将其改为8

//code3
#include <iostream>
#include <vector>
using namespace std;

#define MAX_NUM 8	//MAX_NUM修改为8，其余地方不做任何修改

int main(){
	vector<int> vecInt;
	
	for(int i = 0; i != MAX_NUM; i++){
		vecInt.push_back(i);
	}

	vector<int>::iterator iter = vecInt.begin();
	cout << "the 1st element: " << *iter << endl;
	
	vecInt.push_back(123);
	
	while(iter != vecInt.end()){
		cout << *iter << " ";
		iter++;
	}
	
	return 0;
}

我们只修改MAX_NUM的值，其他地方保留和code2一样，再次运行的时候，程序崩溃了！

• 对于vector来说，和数组最大的区别之一，就是不需要在初始化的时候声明vector的大小。如果初始化的时候没有指明vector的大小，那么会根据实际的使用情况，在内存中为vector分配的大小分别 2 -> 4 -> 8 -> 16 … 。
• MAX_NUM是8，所以在for进行push_back之后，vecInt在内存中的大小为8。 对vecInt再次将元素123进行push_back的时候，新的vector大小将超过当前的vector大小，所以会自动重新分配存储空间。
• 由于vector的存储空间已经被重新分配，在push_back(123)之后，iter自然也就会指向一个未知的空间。所以会导致程序异常。

可以使用capacity()验证

#include <iostream>
#include <vector>
using namespace std;

#define MAX_NUM 8

int main(){
	vector<int> vecInt;
	
	for(int i = 0; i != MAX_NUM; i++){
		vecInt.push_back(i);
	}
	cout << vecInt.capacity() << endl;

	vector<int>::iterator iter = vecInt.begin();
	cout << "the 1st element: " << *iter << endl;
	
	vecInt.push_back(123);
	cout << vecInt.capacity() << endl;

//	先注释掉会崩溃的代码
//	while(iter != vecInt.end()){
//		cout << *iter << " ";
//		iter++;
//	}
	
	return 0;
}

当MAX_NUM为8的时候，在for进行push_back之后，vector的占用的空间是8，再次push_back(123)之后，vector所占空间变成了16。重新自动分配了内存空间，所以iterator会失效。

重新将MAX_NUM修改位9，执行结果如下：

在一开始的时候vector所占用的空间是16，进行push_back的时候空间足够，所以不需要重新分配，所以iterator依然有效，可以用iterator遍历vector。

3、reserve（）避免多次不必要的扩容

成员方法	功能
capacity()	告诉我们当前 vector 容器总共可以容纳多少个元素。如果想知道当前 vector 容器有多少未被使用的存储空间，可以通过 capacity()-size() 得知。注意，如果 size() 和 capacity() 返回的值相同，则表明当前 vector 容器中没有可用存储空间了，这意味着，下一次向 vector 容器中添加新元素，将导致 vector 容器扩容。
size()	告诉我们当前 vector 容器中已经存有多少个元素，但仅通过此方法，无法得知 vector 容器有多少存储空间。
reserve(n)	强制 vector 容器的容量至少为 n。注意，如果 n 比当前 vector 容器的容量小，则该方法什么也不会做；反之如果 n 比当前 vector 容器的容量大，则 vector 容器就会扩容。

reserve的作用是更改vector的容量（capacity），使vector至少可以容纳n个元素。

• 如果n大于vector当前的容量，reserve会对vector进行扩容。其他情况下都不会重新分配vector的存储空间

实例说明

在main中声明了两个vector，vecInt为默认初始化，vecIntB使用capacity初始化其容量为100。分别对vetIntA和vecIntB进行同样的操作：

• ①把0~99依次push_back到vector中，
• ②在push_back的过程中观察vector的容量capacity是否发生变化。

#include <iostream>
#include <vector>
#include <stdint.h>
using namespace std;

void growPushBack(vector<int> &vec, uint16_t size){
	for(int i = 0; i < 100; i++){ 
		vec.push_back(i);
		if(size != vec.capacity()){
			size = vec.capacity();
			cout << "Capacity changed: " << size << endl;
		}
	}
}
int main(){
	uint16_t sz = 0;
	vector<int> vecIntA;
	sz = vecIntA.capacity();
	//声明vector后未使用reserve，直接进行push_back操作 
	cout << "Making vecIntA growing:" << endl;
	growPushBack(vecIntA, sz);
	
	cout << "\n========separator========\n" << endl;
	
	vector<int> vecIntB;
	sz = vecIntB.capacity();
	//声明vecIntB后用reserve来执行其容量为100 
	vecIntB.reserve(100); 
	cout << "Making vecIntB growing: " << endl;
	growPushBack(vecIntB, sz);
	
	return 0;
}

运行结果分析

• 如果一个vector使用默认的capacity，那么在push_back操作的时候，会根据添加元素的数量，动态的自动分配空间，2^n递增；
• 如果声明vector的时候，显式的使用capacity(size_type n)来指定vector的容量，那么在push_back的过程中（元素数量不超过n），vector不会自动分配空间。

新的疑问：大于capacity指定之后的动态分配

如果用capacity指定了vector的容量，之后push_back的元素数量超过了指定的值，那么之后会怎么动态分配呢？

测试：只修改growPushBack方法中，push_back的次数。其余代码不做修改

void growPushBack(vector<int> &vec, uint16_t size){
	for(int i = 0; i < 110; i++){ 	//改为110个元素
		vec.push_back(i);
		if(size != vec.capacity()){
			size = vec.capacity();
			cout << "Capacity changed: " << size << endl;
		}
	}
}

结果说明：

使用capacity指定vector的容量为n，当push_back的元素数量大于n的时候，会重新分配一个大小为2n的新空间，再将原有的n的元素和新的元素放入新开辟的内存空间中。

（注：重新分配内存，并不会在原有的地址之后紧跟着分配的新的空间，一般会重新开辟一段更大的空间，再将原来的数据和新的数据放入新的空间）

重新分配空间后内存地址的变化

测试：在调用growPushBack前后分别打印vecIntB.begin()的地址：

	cout << &*(vecIntB.begin()) << endl;
	cout << "Making vecIntB growing: " << endl;
	growPushBack(vecIntB, sz);
	cout << &*(vecIntB.begin()) << endl;

参考

1、https://blog.csdn.net/hl_zzl/article/details/84798804