vector容器——STL

vector

与数组非常像，数组是静态空间，而Vector是动态空间。它会随着元素的加入自动扩充空间。

内部结构

是一个单端数组

vector迭代器

vector维护的是一个线性空间，所以无论元素的型别如何，普通指针都可以作为vector的迭代器。vector支持随机存取，而普通指针搞好具备这种能力，所以vector提供的是随机访问迭代器（最强的迭代器：可以随意访问任何位置的数据，支持跳跃式的访问）。

可以检测一下的它的动态扩展的规律：

int main()
{
	vector<int> v;
	for (int i = 0; i < 10; i++)//看看每存储一个数，容器v的容量的变化
	{
		v.push_back(i);
		cout << v.capacity() << " ";//1 2 3 4 6 6 9 9 9 13
	}

	return 0;
}

由此可见容量与动态数组的两倍扩建是不一样的，如果数据量大的话接近于1.5倍的容量扩展。一个vector的容量大于或等于其大小，如果容量等于大小，便是满载，下次再有新增元素的话，整个vector就需要找一块比较大的空间。所谓动态扩展，并不是在原空间的后面接新空间（因为不能保证原空间之后尚有可配置的空间），而是直接重新找一块更大的空间，然后将原空间的数据拷贝到新的更大的空间中，并释放原空间。因此，对vector的任何操作，一旦引起空间的重新配置，指向原vector的所有的迭代器就都失效了（需要注意）。

ps:vector的迭代器是随机访问迭代器，是支持跳跃访问的。

int main()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	v.push_back(50);

	vector<int> ::iterator itbegin = v.begin();
	itbegin = itbegin + 3;
	cout << *itbegin << endl;//40
	return 0;
} 
//判断容器是否可以支持随机访问就可以使用这种方法。

vector的构造函数

int main()
{
	vector<int> v;
	v.push_back(100);
	v.push_back(200);

	vector<int> v2(v.begin(), v.end()); //可以通过传参起始迭代器和结束迭代器。
	vector<int> v2(v);//也可以直接传容器，拷贝构造。
    vector<int> v3(10,100);//十个一百的数据

	return 0;
} 

vector的赋值操作

int main()
{
	vector<int> v;
	v.push_back(100);
	v.push_back(200);

	vector<int> v3;
	v3.assign(v.begin(), v.end());//传参起始迭代器和结束迭代器

	cout << *v3.rbegin() << endl;//200

	return 0;
} 

vector交换操作

交换的本质是指针进行交换。

void printVector(vector<int> v)//专门打印vector中数据的函数
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
}

int main()
{
	vector<int> v;
	v.push_back(100);
	v.push_back(200);

	vector<int> v3(10, 100);
	swap(v, v3);
	printVector(v3);//100 200

	return 0;
} 

输出的结果并不是10个100，而是100 200，说明v和v3实现和互换。

vector大小操作

size()//返回容器中的元素的个数
empty()//判断容器是否为空
capacity()//容器的容量
resize(int num)//重新指定容器的长度为num，若容器变长，则用默认值填充新的位置；如果容器变短，则末尾超出容器长度的元素被删除
resize(int num,elem)//重新指定容器的长度为num，若容器变长，则用elem填充新的位置；如果容器变短，则末尾超出容器长度的元素被删除
reserve()//容器预留len个元素长度，如果预留位置不初始化，那么元素不可访问。

vector数据存取操作

at(int idx)//返回idx所指的数据，如果idx越界，抛出out_of_range异常
operator [idx]//返回idx所指的数据，越界时，运行直接报错
//上面两个操作与string存区操作一致，下面的为vector独有
front()//返回容器中的首元素
back()//返回容器中的尾元素

vector插入和删除操作

//对于容器而言，pos指的位置都是迭代器而不是int类型。

insert(const_iterator pos,int count,ele)//在迭代器指向的pos位置插入count个元素ele（原来如果有元素需要后移）count可以不加。
push_back(ele)//尾部插入元素ele
pop_back()//删除最后一个元素
erase(const_iterator start,const_iterator end)//删除迭代器从start到end之间的元素，如果只传一个迭代器，那么就只删传入的迭代器对应的数据
clear()//将容器中的数据全部清空。

这个删除要注意与string中的erase区别，string中的是从指定位置删除n个字符，而vector是删除指定的范围。

插入也有区别，string中可以直接插入字符串，而vector中只能插入指定数目的元素。

小案例

案例1：巧用swap收缩内存

int main()
{
	vector<int> v;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);
	}
	cout << v.capacity() << endl;//138255
	cout << v.size() << endl;//100000

	return 0;
} 

由上面的代码可知，如果存入100000个数，那么系统就会将容器容量自动扩充到138255个空间。

如果觉得存入的数过多，减少了储存的数：使用resize重新规定了

int main()
{
	vector<int> v;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);
	}
	v.resize(3);
	cout << v.capacity() << endl;//138255
	cout << v.size() << endl;//3

	return 0;
} 

发现容器的容量没有变化，只有存储数据量改变了。导致了占用的空间多，但是使用的空间少，造成资源浪费。

需要收缩内存，可以使用swap。

int main()
{
	vector<int> v;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);
	}
	v.resize(3);
	vector<int>(v).swap(v);//使用swap收缩内存
	cout << v.capacity() << endl;//3
	cout << v.size() << endl;//3

	return 0;
} 

分析：vector<int>(v).swap(v);

一个类型后面加个小括号，就是创建匿名对象，然后使用v来初始化这个对象，初始这个对象的时候会根据v当时的size去给这个对象开辟空间，然后这个匿名对象和v对象进行交换，交换的本质是指针进行交换，匿名对象指向了138255大小的空间，而v就指向了3大小的空间。匿名对象还有个特点就是执行完当前行代码以后就会自动释放掉，所以138255的空间就会自动释放。

案例2：巧用reserve预留空间

先写一串代码：

int main()
{
	vector<int>v;

	int* p = NULL;
	int num = 0;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);
		if (p != &v[0])
		{
			p = &v[0];
			num++;
		}
	}

	cout << num << endl;//30

	return 0;
} 

vecotr容器由动态扩展机制，如果容量不够了，那么就需要重新找一块大的区域，然后将原先的数据拷贝过去。每一次寻找转移区域，首元素地址都会改变。上方代码证明如果向vector容器中放入100000个int数据，vextor会进行30次的动态扩展。可见次数是比较多的，如果已经提前知道了要存入的数据量级是100000，那么利用reserve预留出来100000的空间，防止多次动态扩展。

v.reserve(100000);

在创建后就直接添加上这一句，那么最终的结果就是1，也就是只需要创建一次内存空间即可。

案例3：rbegin rend实现逆遍历

int main()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	v.push_back(50);

	for (vector<int>::reverse_iterator it = v.rbegin(); it != v.rend(); it++)
	{
		cout << *it << endl;
	}

	return 0;
} 

注意这里的迭代器不是iterator，而是reverse_iterator