c++中vector使用详解_c++ vector

一、向量的介绍

向量vector是一种对象实体，能够容纳许多其他类型相同的元素，因此，又被成为容器，与string相同，vector同属于STL(Standard Template Library,标准库)中的一种自定义的数据类型，可以广义上认为是数组的增强版。
  在使用它，需要包含vector头文件，#include< vector>；
  vector容器与数组相比其优点在于他能够根据需要随时自动调整自身的大小以遍容下所要放入的元素。此外，vector也提供了许多的方法。

二、向量的声明以及初始化

vector 型变量的声明以及初始化的形式也有许多, 常用的有以下几种形式：

	int N;
	cin>>N;
	vector<int>v;//声明一个整数型向量，里面没有数据
	vector<int>v1(10);//声明含有10个整型数据,数据会被默认初始化为0的向量
	vector<int>v2(10, 1);//声明一个初始化大小为10，初始值都为1的向量
	vector<int>v3(v2);//声明一个和v2一样的向量
	vector<int>v4(v2.begin(), v2.begin() + 2);//声明一个将v2的第0个到第1个的元素作为初始值的向量,区间为[v2.begin(), v2.begin() + 2),左闭右开
	vector<int>v5(N);//可以声明一个大小为N的动态的向量，这个N不必被初始化,可以通过输入来确定这个容器大小。

1
2
3
4
5
6
7
8
9

除此之外, 还可以直接使用数组来初始化向量：

	int arr[] = { 0,1,2,3,4,5,6 };
	vector<int>v6 = { 0,1,2,3,4 };//列表初始化
	vector<int>v7(arr, arr + 3);//将are数组的前是三个元素作为向量v7的初始值，区间为[arr,arr+3)
	vector<int>v8(&arr[1], &arr[4]);//将arr[1]~arr[4]之间的元素作为向量v8的初始值
1
2
3
4

三、元素的输入以及访问

元素的输入和访问可以像操作普通的数组那样，使用数组下标来输入和访问。
这里使用上面初始化中的几个例子来介绍：
①

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	vector<int>v1(10);//声明含有10个整型数据,数据会被默认初始化为0的向量
	for (int i = 0; i < v1.size(); i++)
		cout << v1[i] << " ";
	return 0;
}
1
2
3
4
5
6
7
8
9
10

②

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	vector<int>v2(10, 1);//声明一个初始化大小为10，初始值都为1的向量
	for (int i = 0; i < v2.size(); i++)
		cout << v2[i] <<" ";
	return 0;
}
1
2
3
4
5
6
7
8
9
10

③

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	int N;
	cin >> N;
	vector<int>v5(N);//可以声明一个大小为N的动态的向量，这个N不必被初始化
	for (int i = 0; i < N; i++)
		cin >> v5[i];
	for (int i = 0; i < v5.size(); i++)
		cout << v5[i] <<" ";
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

还可以使用迭代器it来输出,可以使用自动类型推断auto来声明也可以使用vector::iterator it;来声明
，这么采用auto

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	//vector<int>::iterator it
	vector<int>v1(10);//声明含有10个整型数据,数据会被默认初始化为0的向量
	for ( auto it = v1.begin(); it !=v1.end(); it++)
		cout << *it << " ";
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

*it 为指针的间接访问形式, 意思是访问t所指向的元素值。

四、向量的基本操作

vector<int>a(10,1);
vector<int>b(5);
a.size()                      //获取向量中的元素个数；
a.empty()                     //判断向量是否为空；
a.clear()                     //清空向量中的元素；

a.insert(a.begin(),1000);       //将1000插入到向量a的起始位置前，返回值是一个指向第一个元素的迭代器;
a.insert(a.begin(),3,1000) ;    //将3个1000插入到向量a的起始位置前，返回值是一个指向第一个元素的迭代器；
b.insert(b.begin(),a.begin(),a.end());
//将a.begin(),a.end()之间的全部元素插入到b.begin()前

b.erase(b.begin());//将起始位置的元素删除;
b.erase(b.begin(),b.begin()+3); //将(b.begin(), b.begin()+3)之间的元素删除;
b.swap(a);//a向量与b向量进行交换
//这里将向量a和向量b互换效率很高，因为a和b之间交换了内部的数据结构，
//不是简单的内部数据交换。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

插入代码举例

	vector<int>a(10, 1);
	vector<int>b(5);
	a.insert(a.begin(), 100);//将100插入到向量a的起始位置前;
	for (int i = 0; i < a.size(); i++)
	{
		cout << a[i] << " ";
	}
1
2
3
4
5
6
7

	vector<int>a(10, 1);
	vector<int>b(5);
	a.insert(a.begin(),3, 100);//将3个100插入到向量a的起始位置前;
	for (int i = 0; i < a.size(); i++)
	{
		cout << a[i] << " ";
	}
1
2
3
4
5
6
7

	vector<int>a(10, 1);
	vector<int>b(5);
	a.insert(a.begin(), b.begin(), b.end());
	for (int i = 0; i < a.size(); i++)
	{
		cout << a[i] << " ";
	}
1
2
3
4
5
6
7

删除代码举例
①使用成员函数来删除元素

	vector<int>b(5);
	b.erase(b.begin());//将起始位置的元素删除;
	b.erase(b.begin(),b.begin()+3); //将(b.begin(), b.begin()+3)之间的元素删除;
1
2
3

②使用迭代器来删除元素
错误的例子：

	vector<int>v={1,2,1,3,4};
	for (auto it = vec.begin(); it != vec.end(); ++it)
	{
    	if (1 == *it) {
       	 vec.erase(it);
    	}    
	}
1
2
3
4
5
6
7

错误原因：因为删除会造成vector的容量和地址改变，所以迭代器就会失效，造成错误。
正确使用迭代器删除元素：

	vector<int>v{ 1,2,1,3,4 };
	for (auto it = v.begin(); it !=v.end() ; )
	{
		if (*it == 1)
			it = v.erase(it);//更新迭代器，erase()返回值是一个指向被删除元素后一个元素的迭代器
		else
			++it;//更新迭代器
	}
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
1
2
3
4
5
6
7
8
9
10
11
12

交换swap代码举例

	vector<int>a(10, 1);
	vector<int>b(5);
	a.swap(b);//这里不但交换元素值，而且交换了元素个数，
	for (int i = 0; i < a.size(); i++)
	{
		cout << a[i] << " ";
	}
	cout << endl;
	for (int i = 0; i < b.size(); i++)
	{
		cout << b[i] << " ";
	}
//根据c++ primer的解释，这里的交换是内部数据结构的交换，比一般复制效率高很多
1
2
3
4
5
6
7
8
9
10
11
12
13

五、二维向量

同样可以使用vector来达到多维数组的效果
例如二维数组：

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	vector<vector<int>>v9 (10,vector<int>(5,1));
	for (int i = 0; i < v9.size(); i++)
		{
			for (int j = 0; j < v9[i].size(); j++)
			{
				cout << v9[i][j] << " ";
			}
			cout << endl;
		}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

##vector类，常见的功能(成员函数)

   c.back()      // 传回最后一个数据，不检查这个数据是否存在。
   c.begin()     // 传回迭代器中的第一个数据地址。
   c.capacity()  // 容器在必须分配存储空间之前可以存储元素的总数
   c.clear()     // 移除容器中所有数据。
   c.empty()     // 判断容器是否为空。
   c.end()       // 指向迭代器中末端元素的下一个，指向一个不存在元素。也叫"逾尾"和"超尾"。
   c.erase(pos)  // 删除pos位置的数据，返回一个指向被删元素下一个元素的迭代器。
   c.erase(beg,end)  //删除[beg,end)区间的数据，返回一个指向被删元素下一个元素的迭代器。
   c.front()     // 传回第一个数据。
   
   get_allocator // 使用构造函数返回一个拷贝。

   c.insert(pos,elem)    // 在pos位置插入一个elem拷贝，传回新数据位置。
   c.insert(pos,n,elem)  // 在pos位置插入n个elem数据。无返回值。
   c.insert(pos,beg,end) // 在pos位置插入在[beg,end)区间的数据。无返回值。
　　
   c.max_size()       // 返回容器中最大数据的数量。
   c.pop_back()       // 删除最后一个数据。
   c.push_back(elem)  // 在尾部加入一个数据。
   c.rbegin()         // 传回一个逆向队列的第一个数据。
   c.rend()           // 传回一个逆向队列的最后一个数据的下一个位置。
   c.resize(num)      // 重新指定队列的长度。
   c.reserve()        // 保留适当的容量。
   c.size()           // 返回容器中实际数据的个数。
   c1.swap(c2)
   swap(c1,c2)        // 将c1和c2元素互换。同上操作。

   operator[]         // 返回容器中指定位置的一个引用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28