C++:vector类

vector的介绍及使用

vector的定义

(1)vector<int> a;//无参构造
(2)vector<int> a(10,1); //定义了10个整型元素的向量,且给出每个元素的初值为1
(3)vector<int> a(b); //用b向量来创建a向量，整体复制性赋值，拷贝构造
(4)vector<int> a(b.begin(),b.begin+3); //定义了a值为b中第0个到第2个（共3个）元素
(5) vector<int> a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），初值默认0。
(6)int b[7]={1,2,3,4,5,9,8}; vector<int> a(b,b+7); //从数组中获得初值

vector iterator 的使用

vector 空间增长问题

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

int main()
{
	vector<int> v;
	cout << v.size()<<endl;//0
	cout << v.capacity() << endl;//0
	cout << v.empty() << endl;//1
    return 0;
}

capacity 的代码在 vs 和 g++ 下分别运行会发现， vs 下 capacity 是按 1.5 倍增长的， g++ 是按 2 倍增长的 。

这个问题经常会考察，不要固化的认为， vector 增容都是 2 倍，具体增长多少是根据具体的需求定义的。vs 是 PJ 版本 STL ， g++ 是 SGI 版本 STL 。

reserve 只负责开辟空间，如果确定知道需要用多少空间， reserve 可以缓解 vector 增容的代价缺陷问题。

resize 在开空间的同时还会进行初始化，影响 size 。

#include<iostream>
#include<algorithm>
using namespace std;
#include<vector>
int main()
{

	// 测试vector的默认扩容机制
	
		size_t sz;
		vector<int> v;
		sz = v.capacity();
		cout << "making v grow:\n";
		for (int i = 0; i < 100; ++i)
		{
			v.push_back(i);
			if (sz != v.capacity())
			{
				sz = v.capacity();
				cout << "capacity changed: " << sz << '\n';
			}
		}
	
	/*vs：运行结果：vs下使用的STL基本是按照1.5倍方式扩容
		making foo grow :
	    capacity changed : 1
		capacity changed : 2
		capacity changed : 3
		capacity changed : 4
		capacity changed : 6
		capacity changed : 9
		capacity changed : 13
		capacity changed : 19
		capacity changed : 28
		capacity changed : 42
		capacity changed : 63
		capacity changed : 94
		capacity changed : 141

     g++运行结果：linux下使用的STL基本是按照2倍方式扩容
        making foo grow:
        capacity changed: 1
        capacity changed: 2
        capacity changed: 4
        capacity changed: 8
        capacity changed: 16
        capacity changed: 32
        capacity changed: 64
        capacity changed: 128*/
	
    return 0;
}

 resize

用法：
a.resize(10); //将a的现有元素个数调至10个，多则删，少则补，补的话其值默认0，容量不变
a.resize(10,2); //将a的现有元素个数调至10个，多则删，少则补，补的话其值为2，容量不变

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

int main()
{
	vector<int> v;

	v.resize(10);
	cout << v[1] << endl;//0
	cout << v.size()<<endl;//10
	cout << v.capacity() << endl;//10

    return 0;
}

 reserve

a.reserve(100); //将a的容量（capacity）扩充至100，也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能） 

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

int main()
{
	vector<int> v;

	v.reserve(10);
	cout << v.size()<<endl;//0
	cout << v.capacity() << endl;//10

    return 0;
}

vector 增删查改

a.push_back(5); //在a的最后一个向量后插入一个元素，其值为5

a.pop_back(); //删除a向量的最后一个元素

a.insert(a.begin()+1,5); //在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4

a.insert(a.begin()+1,3,5); //在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5

a.insert(a.begin(), s.begin(), s.end());//在a的第0个元素（从第0个算起）的位置插入
s[begin,end)的元素

a.insert(a.begin()+1,b+3,b+6); //b为数组，在a的第1个元素（从第0个算起）的位置插入b的
（从第0个算起）第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8，插入元素后1,4,5,9,2,3,4,5,9,8

a.erase(a.begin()+1,a.begin()+3); //删除a中第1个（从第0个算起）到第2个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+3（不包括它）[begin()+1,a.begin()+3)

a.erase(a.begin());//删除第0个元素

a.swap(b); //b为向量，将a中的元素和b中的元素进行整体性交换

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

int main()
{
	vector<int> v(10, 1);

	for (size_t i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";//1 1 1 1 1 1 1 1 1 1
	}
	cout << endl;
	
    return 0;
}

算法模块
头文件#include<algorithm>，不在vector中

find(a.begin(),a.end(),10); //在a中的从a.begin()（包括它）到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置

reverse(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素为1,3,2,4,倒置后为4,2,3,1
[a.begin(),a.end()),左闭右开

sort(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素进行从小到大排列

copy(a.begin(),a.end(),b.begin()+1); //把a中的从a.begin()（包括它）到a.end()（不包括它）的元素复制到b中，从b.begin()+1的位置（包括它）开始复制，覆盖掉原有元素

其他

shrink_to_fit

要求容器减少其容量以适应其尺寸，适应有效数据个数

assign

a.assign(b.begin(), b.begin()+3); //b为向量，将b的0~2位置的元素构成的向量赋给a
a.assign(4,2); //a只含4个元素，且每个元素为2

vector非成员函数

会调用即可