c++之vector详解

飒飒ai

已于 2022-09-20 17:14:06 修改

阅读量2.1k

点赞数 4

分类专栏： c++入门文章标签： c++ 算法数据结构

于 2022-09-20 17:02:56 首次发布

本文链接：https://blog.csdn.net/qq_55537010/article/details/126956933

版权

c++入门专栏收录该内容

2 篇文章 1 订阅

订阅专栏

1. vector容器简介

容器：vector
算法：for_each
迭代器：vector::iterator

vector的用法类似于数组，不同的是，普通数组创建的是静态数组，即创建时就已经指定了其大小，不可以更改；而vector数组创建的时动态数组，即创建后还可以根据需求扩充、缩小其大小。
vector数组虽然是动态数组，但支持随机存取，原因是vector数组申请的是一块连续的内存空间，当对其进行扩容时，系统会寻找另一块更大的连续的内存空间，然后将原空间的数据拷贝到新空间。
vector数组虽然可以动态指定大小，但是由于扩容时需要将数据全部拷贝一遍，造成的开销时不可忽略的(每次重新构造和时间复杂度为logn)。

2. vector创建

2.1 包含头文件

#include<vector>      //包含vector、map等各种容器
#include<algorithm>   //包含for_each等算法，容器和算法通过迭代器衔接

2.2 vector数组的创建和使用

/*一维数组的创建*/
vector<int> v;      						//默认构造
vector<int> v1(3,20)						//有参构造：长度为3，值为20
vector<int> v1(5)                           //有参构造：长度为5，值为默认值0
vector<int> v2(v1)      					//拷贝构造
vector<int> v3(v2.begin(),v2.begin())      	//迭代器构造
vector<int> v4 = {1,2,3,4}                  //数组构造   
int array[] = {1,2,3,4};
vector<int> v4(array,array+sizeof(array)/sizeof(int));   //数组构造
/*vector容器的插入*/
/**vector尾部插入**/
v.push_back(10);
v.push_back(20);
//v = {1,2,3,4}  //这样也是可以的
/**vector在指定位置插入**/
v.insert(v.begin(),30);     //插入到首部
v.insert(v.begin()+1,20)    //这里要注意第一个参数的大小，防止访问越界
/*二维数组的创建(容器中嵌套容器)*/
vector<vector<int>> vv;
/*vector容器的插入*/
/**vector尾部插入**/
vv.push_back(v);
vv.push_back(v1);
vv.push_back(v2);
/**vector在指定位置插入**/
vv.insert(vv.begin(),v1);

这里补充一下vector动态分配内存过程：

初始化：vector m_vector(6,0),此时vector分配6个int的连续内存大小。

分配连续内存

当在其中压入一个元素时，执行m_vector.capacity()可以发现容器容量（Capacity）为10，系统会寻找一块内存为10的连续内存重新分配给m_vector。
当再次压入4个元素时，执行容量变为20，再次压入适当的元素时容量变化为30、45…

可见，容器的容量增加是按照非线性增加的，也可以说明capacity()和size()的区别。

对于嵌套容器（二维动态数组），容器中的每个元素都是指向另一个一维容器的指针，通过这样的方法来实现二维数组的创建。需要注意的是，二维容器的每个元素的地址是不连续的，但是每个指针指向的容器内存是连续的，这和二维数组的存储是有区别。
二维数组是不可以直接赋值给vector的。

2.3 vector的遍历与访问

void myPrint(int val)
{
	cout << val << endl;
}
int main()
{ 
    ...
    ...
/*第一种遍历的写法*/
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << endl;
	}
/*第二种遍历写法    利用STL中提供的遍历算法*/
	for_each(v.begin(), v.end(), myPrint);
/*vector也可以按数组的方式随机访问与存储*/
    cout<<v[1]<<endl;
    v[1] = 10;
/**************************************/
 /*容器嵌套容器遍历*/
 	for (vector<vector<int>>::iterator it = vv.begin(); it != vv.end(); it++)
    {
		for (vector<int>::iterator it1 = (*it).begin(); it1 != (*it).end(); it1++)
		{
			cout << *it1 << " ";
		}
		cout << endl;
	}   
  /*容器的随机访问*/
  cout << vv[2][2] << endl;
  vv[1][0] = 10;
    ...
}

2.3 容器中放置自定义的数据类型

for(vector<Person>::iterator it = v.begin(); it !=v.end(); it++)
{
    cout << (*it).m_Name << (*it).m_Age << endl;
}

2.4 vector的成员函数

Iterators:

//迭代器
v.begin();      //返回指向第一个元素的迭代器
v.end();		//返回指向最后一个元素的迭代器
v.rbegin();     //返回指向最后一个元素的反向迭代器
v.rend();		//返回指向第一个元素的反向迭代器
v.cbegin();		//返回指向第一个元素的常量迭代器，常量迭代器指向的内容不可以修改，下同
v.cend();
v.crbegin();
v.crend();

Capacity:

/*vector大小*/
v.size();					//返回vector中已有元素个数
v.max_size();				//返回vector最大可支持扩展的容量
/*resize的两种方法*/
/*
* 1.如果n小于v.size()，则只保留vector的前n个元素，其他的将被销毁
* 2.如果n大于v.size()，vector将在末尾插入元素（如果未指定val，默认为0）使其size等于n，但不改变原来的值
* 3.如果n大于v.capacity()，将会重新开辟合适空间，并拷贝所有数据
*/
v.resize (size_type n);
v.resize(size_type n, const value_type& val);	
/****/
v.capacity();				//返回vector目前的容量，注意capacity！=size
v.empty();					//如果vector为空则返回true，否则返回false
v.reserve(size_type n);		//请求改变vector容器容量，至少可以容纳n个元素
v.shink_to_fit();           //使容器自由优化至合适的大小（保证容量大于其大小）

Element access:

/*元素访问*/
v[1] = 1;					//使用运算符[]
v.at(size_type n);			//返回位置为n的元素的引用
v.front();					//返回第一个元素的引用
v.back();					//返回最后一个元素的引用
v.data();					//返回一个指向第一个元素的指针，该指针可以结合[]运算符进行随机访问、存储

Modifiers:

/*元素修改*/
v.assign();					//为vector重新分配新的内容，替代原内容，这与resize()有区别的
/*assign的三种方法*/
/*
* 1.调用方法时，首先会销毁vector中的所有元素
* 2.当n大于v.capacity()，将会重新开辟合适空间.
*/
v.assign (InputIterator fir st, InputIterator last);  //使用迭代器分配 [first,last)
v.assign (size_type n, const value_type& val);       //使用val值填充
v.assign (initializer_list<value_type> il); 		 //使用数组填充
/********/
v.push_back();
v.pop_back();
v.insert();					//在指定位置前插入新元素
/*
/*insert()的四种调用方法*/
  1. v.insert(position,n,val)
  2. v.insert(pos,val)
  3. v.insert(it,v2.begin(),v2.begin()+2)    //it为v的迭代器
  4. v.insert(it,i1)       //it为v的迭代器，i1为数组
/************/
*/
v.erase();					//每次执行删除，后面的元素都要移动，效率较低
/*
* 1.指定位置删除
    v.erase (const_iterator position);
  2.迭代器范围删除
  	v.erase (const_iterator first, const_iterator last);
*/
v.swap(vector& x);			//交换两个容器的元素，交换后容器的大小（size）也会发生改变
v.clear();					//清除vector中所有元素。size为0，capacity不变					
v.empalce(const_iterator position, Args&& args);//向vector中插入新元素，返回指向该元素的指针
v.emplace_back();           //向vector末尾插入新元素

2.5 示例

#include<iostream>
#include<vector>         
#include<algorithm>     //for_each()调用
using namespace std;

void test01()
{
	vector<vector<int>>v;
	vector<int>v1;
	vector<int>v2;
	vector<int>v3;
	vector<int>v4;
	for (int i = 0; i < 4; i++)
	{
		v1.push_back(i + 1);
		v2.push_back(i + 2);
		v3.push_back(i + 3);
		v4.push_back(i + 4);
	}
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);
	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
	{
		for (vector<int>::iterator it1 = (*it).begin(); it1 != (*it).end(); it1++)
		{
			cout << *it1 << " ";
		}
		cout << endl;
	}
}
int main()
{
	test01();
}

#include<iostream>
#include<vector>

using namespace std;

void myPrint(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << (*it) << " ";
	}
	cout << endl;
}
void test01()
{
	vector<int>v;
	v.reserve(50); //为容器预留空间，减少动态分配内存所花费的时间
	for (int i = 10; i < 60; i++)
	{
		v.push_back(i);
	}
	myPrint(v);
	cout <<"v的大小为：" << v.size() << endl;
	cout <<"v的容量为： "<< v.capacity() << endl;
	v.insert(v.begin() + 5, 10, 1000);//迭代器，插入的个数，插入的值
	v.erase(v.begin(), v.begin() + 2);//删除，第一个参数为迭代器
	v.pop_back();//尾删
	myPrint(v);
	v[5] = 1111; //vector中数据的随机存取
	//两种访问的方式
	cout << v[5] << endl;
	cout << v.at(5) << endl;
	vector<int>v1;
	v1.swap(v);
	myPrint(v1);	
}