【C++】STL标准模板库容器vector
🦄个人主页:修修修也
🎏所属专栏:C++
⚙️操作环境:Visual Studio 2022
编辑
目录
📌 vector 对 象集合的迭代遍 历 及元素 访问 操作
🎏 data 获 取指向 vector中第一个元素位置的指 针
vector对象集合简介
标准库类型vector表示对象的集合,其中所有对象的类型都相同.集合中的每个对象都有一个与之对应的索引,索引用于访问对象.因为vector"容纳着"其他对象,所以它也常被称作容器(container).vector 是 C++ 标准模板库（STL）的一部分，提供了灵活的接口和高效的操作,它们都位于<vector>头文件中。
我们先来看一下cplusplus.com - The C++ Resources Network 网站对vector类的文档介绍:vector 类 文档 
编辑
总结如下:
1. C++ 中的 vector 是一种序列容器，它允许你在运行时动态地插入和删除元素。
2. vector 的大小可以根据需要自动增长和缩小。
3. vector 中的元素在内存中是连续存储的，这使得访问元素非常快速。
4. vector 可以被迭代，你可以使用循环（如 for 循环）来访问它的元素。
5. vector 可以存储任何类型的元素，包括内置类型、对象、指针等。
6. 要想使用vector ,必须包含适当的头文件,如下using声明:
7. #include<vector>
using std::vector;
vector对象集合常用接口(成员函数)
📌vector对象集合模板默认成员函数
🎏vector对象集合模板构造函数
如下,C++98标准中对于vector类实现了4个重载的构造函数:
编辑
其参数解析如下:
编辑
接下来我们演示使用这四种vector类构造函数(该部分演示会涉及一部分迭代遍历和元素访问操作,还不太了解的朋友可以先看一下vector的迭代遍历及元素访问操作):
|
函数名称 |
功能说明 |
|
|
explicit vector (const allocator_type& alloc = allocator_type()); |
构造一个没有元素的空容器。 |
|
|
explicit vector (size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type()); |
构造一个包含 n 个元素的容器。每个元素都是 val 的拷贝。 |
|
|
template <class InputIterator> vector (InputIterator first,InputIterator last, const allocator_type& alloc = allocator_type()); |
构造一个容器，其元素数与范围 [first，last] 一样多，每个元素按相同的顺序由该范围中的相应元素构造。 |
|
|
vector (const vector& x); |
构造一个容器，其中包含 x 中每个元素的拷贝，顺序相同。 |
注:vector构造函数中出现的alloc参数是空间配置器/内存池,由于vector要频繁的申请和释放空间,为了提高获取和释放空间的效率,就引入了一个内存池变量作为缺省参数.关于内存池的部分我们暂时不在初步学习C++的时候讲解,只在此提及一下,方便大家理解vector的构造函数的组成.
编辑
如下代码,分别按上述构造函数顺序调用了相应构造函数初始化了4个vector对象集合:
#include<vector>
#include<iostream>
using namespace std;
int main()
{
//构造空的vector对象集合,即空容器
vector<int> v1;
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
//构造一个包含 10 个元素的容器。每个元素都是 1 的拷贝。
vector<int> v2(10,1);
for (auto e : v2)
{
cout << e << " ";
}
cout << endl;
//构造一个容器，其元素数与范围 [v2.begin()，v2.end()] 一样多
//每个元素按相同的顺序由该范围中的相应元素构造。
vector<int> v3(v2.begin(),v2.end());
for (auto e : v3)
{
cout << e << " ";
}
cout << endl;
//构造一个容器，其中包含 v3 中每个元素的拷贝，顺序相同。
vector<int> v4(v3);
for (auto e : v4)
{
cout << e << " ";
}
cout << endl;
return 0;
} 运行程序,构造对象集合结果如下:
编辑
注意,对于vector的迭代器构造还有一些别的玩法,我们可以使用vector自己的迭代器构造vector,如:
编辑
还可以使用别的类型的迭代器构造vector,如:
编辑
甚至可以不用迭代器,使用类似于迭代器的指针也可以构造vector,如:
编辑
但需要注意的是,在使用不同类型的迭代器构造时需要保证它们的基本元素类型与vector对象集合一致,否则将导致数据隐式类型转换.
🎏vector对象集合模板析构函数
如下,C++中对于vector类实现了1个析构函数:
编辑
该函数没有参数,没有返回值,在类对象生命周期结束后自动调用销毁对象集合.
🎏vector对象集合模板赋值运算符重载
如下,C++98标准中对于vector类实现了1个赋值运算符重载函数:
编辑
接下来我们演示使用这种常见的vector类赋值运算符重载函数:
如下代码,调用了相应赋值运算符重载函数把v1赋值给了vector类对象v2:
int main()
{
//构造一个包含 10 个元素的容器。每个元素都是 1 的拷贝。
vector<int> v1(10, 1);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
vector<int> v2;
//将v1赋值给v2
v2 = v1;
for (auto e : v2)
{
cout << e << " ";
}
cout << endl;
return 0;
}运行程序,调用赋值运算符重载函数结果如下:
编辑
📌vector对象集合的迭代遍历及元素访问操作
vector对象集合的迭代器相关函数共有8个,如下:
编辑
vector对象集合的元素访问相关函数共有五个,如下:
编辑
接下来我们演示学习几种常见的vector对象集合的迭代遍历及元素访问函数:
🎏operator[]运算符重载
operator[]运算符重载定义:
编辑
注意:operator[]和at()函数的不同之处在于 vector：：at 是边界检查的，并在请求的位置超出范围时通过抛出out_of_range 异常来发出信号。
operator[]遍历vector对象集合:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
//使用operator[]遍历vector
for (int i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
return 0;
}
编辑
operator[]修改vector对象集合:
因为operator[]返回的是引用类型,因此可以利用其对vector对象集合进行修改:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
//使用operator[]修改vector
for (int i = 0; i < v1.size(); i++)
{
++v1[i];
cout << v1[i] << " ";
}
cout << endl;
return 0;
}
编辑
🎏at访问对象集合某位置元素
at()函数定义:
编辑
at()函数遍历vector对象集合:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
//使用at()函数遍历vector
for (int i = 0; i < v1.size(); i++)
{
cout << v1.at(i) << " ";
}
cout << endl;
return 0;
}
at()函数遍历对象集合效果如下:
编辑
at()函数修改vector对象集合:
因为at()函数返回的是引用类型,因此可以利用其对vector对象集合进行修改:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
//使用at()函数修改vector
for (int i = 0; i < v1.size(); i++)
{
++v1.at(i);
cout << v1.at(i) << " ";
}
cout << endl;
return 0;
}
编辑
🎏顺序迭代器begin+end
begin+end迭代器顺序遍历访问vector对象集合:
begin()函数定义如下:
编辑
end()函数定义如下:
编辑
begin+end迭代器顺序遍历访问vector对象集合:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
//使用begin+end迭代器顺序遍历vector
vector<int>::iterator it = v1.begin();
while (it != v1.end())
{
cout << *it << " ";
++it;
}
return 0;
}
begin+end迭代器顺序遍历访问对象集合效果如下:
编辑
begin+end迭代器修改vector对象集合:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
//使用begin+end迭代器修改vector
vector<int>::iterator it = v1.begin();
while (it != v1.end())
{
++(*it);
cout << *it << " ";
++it;
}
return 0;
}
编辑
🎏反向迭代器rbegin+rend
rbegin+rend逆序遍历访问vector对象集合:
rbegin()函数定义如下:
编辑
rend()函数定义如下:
编辑
使用rbegin+rend迭代器反向遍历访问vector对象集合:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
//使用rbegin+rend迭代器反向遍历vector
vector<int>::reverse_iterator rit = v1.rbegin();
while (rit != v1.rend())
{
cout << *rit << " ";
++rit;
}
return 0;
}
编辑
使用rbegin+rend反向迭代器修改vector对象集合:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
//使用rbegin+rend迭代器修改vector
vector<int>::reverse_iterator rit = v1.rbegin();
while (rit != v1.rend())
{
++(*rit);
cout << *rit << " ";
++rit;
}
return 0;
}
编辑
🎏范围for
C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量， 第二部分则表示被迭代的范围。(注:知道数据类型的情况下可以不使用auto关键字自动推导类型)
范围for顺序访问vector对象集合:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
//使用范围for遍历vector
for(auto e : v1)
{
cout << e << " ";
}
return 0;
}
范围for顺序访问vector对象集合效果如下:
编辑
范围for修改vector对象集合:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
//使用范围for修改vector
for(auto &e : v1)
{
e++;
cout << e << " ";
}
return 0;
}
编辑
🎏data获取指向vector中第一个元素位置的指针
data()函数定义如下:
编辑
使用data()函数获取vector首元素的位置(演示环境为32位机器,故指针大小为8位):
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
cout << v1.data() << endl;
cout << *(v1.data()) << endl;
cout << v1.front() << endl;
return 0;
}
编辑
🎏sort排序
sort()函数是STL中算法部分的一个接口,其定义如下:
编辑
由定义可知,sort()函数会接收三个参数,分别是待排序区间的初始位置,最终位置和决定排序方法的函数指针.功能是对范围内的元素进行排序.
注意:
1. 最后一个参数有两种,分别是less对象和greater对象
2. less //用来排升序
3.
4. //使用方法如下
5. less<排序元素类型> 变量名
6.
7. //如
8. less<int> le
9.
10.
11. greater //用来排降序
12.
13. //使用方法如下
14. greater<排序元素类型> 变量名
15.
16. //如
greater<int> gt;
17. 调用sort()函数前需要包含头文件
#include<algorithm>
接下来我们演示几种sort()排序的情况:
1.sort()排升序
如下代码,我们创建一个无序的int类型的向量v1,然后使用sort()函数将其排为升序:
//sort()排升序
void test1()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
//升序
//less(一般是默认的,不用传)
less<int> le;
sort(v1.begin(), v1.end(), le);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
}
//sort()排序
int main()
{
test1();
return 0;
}
编辑
注意,sort()函数排升序时,也可以不传最后一个参数,sort()函数也会默认排升序,如:
编辑
2.sort()排降序
如下代码,我们创建一个无序的int类型的向量v1,然后使用sort()函数将其排为降序:
//sort排降序
void test2()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
//降序 greater
greater<int> gt;
//定义一个greater的对象,作为sort函数的参数
sort(v1.begin(), v1.end(), gt);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
}
//sort()排序
int main()
{
test2();
return 0;
}
编辑
注意:因为此处创建greater变量的作用仅仅是帮助sort()函数识别到底是升序还是降序,变量本身的存在没有多大的意义,所以我们可以在传参的时候使用匿名对象来作为sort()的参数,这样,在这一行结束时匿名对象就会销毁,有助于节省程序运行时的栈空间消耗:
//更好的方式是定义一个匿名对象传过去
sort(v1.begin(), v1.end(), greater<int>());
3.sort()利用反向迭代器排序
如下代码,我们创建一个无序的int类型的向量v1,然后使用sort()函数,并给其传入待排区间的反向迭代器,将其排为降序:
//sort排降序
void test3()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
//利用反向迭代器排降序:
//下面这行代码的含义相当于对待排序列逆向排升序,即排降序
sort(v1.rbegin(), v1.rend());
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
}
//sort()排序
int main()
{
test3();
return 0;
}
编辑
4.利用sort()函数给string排序
如下代码,我们创建一个string类型的变量s1,然后使用sort()函数将其内部的字符排为升序:
//sort()排序string
void test4()
{
string s1("hello world");
cout << s1 << endl;
sort(s1.begin(), s1.end());
cout << s1 << endl;
}
//sort()排序
int main()
{
test4();
return 0;
}
编辑
5.利用sort()函数给数组排序
如下代码,我们创建一个无序的int类型的数组a,然后使用sort()函数将其排为升序:
//sort()排序数组
void test5()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
for (auto e : a)
{
cout << e << " ";
}
cout << endl;
sort(a, a + 5);//传入数组的迭代区间
for (auto e : a)
{
cout << e << " ";
}
}
//sort()排序
int main()
{
test5();
return 0;
}
编辑
📌vector对象集合模板的容量操作
vector对象集合容量相关操作函数共有7个,如下:
编辑
接下来我们演示学习几种常见的vector对象集合的容量操作函数:
|
函数名称 |
功能说明 |
|
|
size |
返回vector有效元素长度 |
|
|
resize |
将有效元素的个数改成n个,多出的空间用元素c填充 |
|
|
capacity |
返回vector容量总大小 |
|
|
empty |
检测vector是否为空,是返回true,否则返回false |
|
|
reserve |
更改vector容量 |
🎏size()函数
size()函数定义:
编辑
使用size()函数获取vector有效元素长度:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
//使用size()获取有效元素长度
cout << v1.size() << endl;
return 0;
}
size()函数效果如下:
编辑
🎏capacity()函数
capacity()函数定义:
编辑
使用capacity()函数获取vector对象集合当前存储空间总大小:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
//使用指针构造vector
vector<int> v1(a, a + 5);
//使用capacity()获取vector当前容量
cout << v1.capacity() << endl;
return 0;
}
capacity()函数效果如下:
编辑
🎏empty()函数
empty()函数定义:
编辑
使用empty()函数判断vector对象集合是否为空:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
vector<int> v1(a, a + 5);
vector<int> v2;
//使用empty()检查v1,v2是否为空
cout << v1.empty() << endl;
cout << v2.empty() << endl;
return 0;
}
编辑
🎏resize()函数
resize()函数定义:
编辑
使用resize()函数调整vector对象集合有效元素大小:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
vector<int> v1(a, a + 5);
vector<int> v2;
//使用size()获取vector当前有效元素数量
cout << v1.size() << endl;
cout << v2.size() << endl;
//使用resize()修改vector当前有效元素数量
v1.resize(15);
v2.resize(10);
//使用size()获取vector当前有效元素数量
cout << v1.size() << endl;
cout << v2.size() << endl;
return 0;
}
resize()函数效果如下:
编辑
🎏reserve()函数
reserve()函数定义:
编辑
使用reserve()函数更改vector对象集合容量大小:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
vector<int> v1(a, a + 5);
vector<int> v2;
//使用capacity()获取vector当前容量
cout << v1.capacity() << endl;
cout << v2.capacity() << endl;
//使用reserve()修改vector当前容量
v1.reserve(15);
v2.reserve(10);
//使用capacity()获取vector当前容量
cout << v1.capacity() << endl;
cout << v2.capacity() << endl;
return 0;
}
reserve()函数效果如下:
编辑
reserve()函数使用常见误区:
如下代码,我们有时会使用reserve()开辟好空间后直接使用operator[]来给vector赋值,这样是完全错误的使用方法,它会导致程序运行报错:
//resever()易错
int main()
{
vector<int> v1;
v1.reserve(10);
for (int i = 0; i < 10; i++)
{
v1[i] = i;
//错误,因为reserve只改变了capacity,没有改变size
//而operator[]访问时需要断言检查是否<size
}
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
return 0;
}
编辑
原因就在于operator[]只能访问vector的有效数据,即size范围内的数据,而对于capacity范围内但是size范围外的数据,operator[]是不能访问的,如果非要访问,则相当于越界访问,程序就会报错.对于这个问题,有两种解决方案,一种是,当我们使用reserve()函数修改vector容量时,填入数据就使用push_back()函数,如:
vector<int> v1;
v1.reserve(10);
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
编辑
还有一种方法就是,当我们要使用operator[]来给vector赋值时,前面就要先用resize()调整vector有效元素的数量,便于避免operator[]非法访问,如:
vector<int> v1;
v1.resize(10);
for (int i = 0; i < 10; i++)
{
v1[i] = i;
}
编辑
📌vector对象集合模板的成员修改操作
vector对象集合的成员修改函数共有9个,如下:
编辑
常用的vector修改操作:
|
函数名称 |
功能说明 |
|
|
push_back |
在字符串后尾插字符c |
|
|
pop_back |
删除vector最后一个元素 |
|
|
insert |
在vector中n位置插入x |
|
|
erase |
删除vector中n位置元素 |
🎏push_back()函数
push_back()函数定义:
编辑
使用push_back()函数在vector对象集合后追加元素:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
vector<int> v1(a, a + 5);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.push_back(8);
v1.push_back(6);
v1.push_back(9);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
return 0;
}
push_back()函数效果如下:
编辑
🎏pop_back()函数
pop_back()函数定义:
编辑
使用pop_back()函数删除vector对象集合中最后一个元素:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
vector<int> v1(a, a + 5);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.pop_back();
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
return 0;
}
pop_back()函数删除vector对象集合最后一个元素效果如下:
编辑
🎏insert()函数
insert()函数定义:
编辑
使用insert()函数在vector对象集合中第三个位置插入1个8:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
vector<int> v1(a, a + 5);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.insert(v1.begin() + 2 , 8);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
return 0;
}
编辑
使用insert()函数在vector对象集合中第三个位置插入3个8:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5 };
vector<int> v1(a, a + 5);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.insert(v1.begin() + 2 , 3 , 8);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
return 0;
}
编辑
🎏erase()函数
erase()函数定义:
编辑
使用erase()函数删除vector对象集合中第三个位置的元素:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5,8,6,0,9,7 };
vector<int> v1(a, a + 10);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.erase(v1.begin() + 2);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
return 0;
}
编辑
使用erase()函数删除vector对象集合中第三个位置到第六个位置的元素:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5,8,6,0,9,7 };
vector<int> v1(a, a + 10);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.erase(v1.begin() + 2 , v1.begin() + 6 );
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
return 0;
}
编辑
🎏find()函数及其应用
find()函数定义:
编辑
由定义可知,find()函数接收三个参数,分别是代表开始查找范围的迭代器first,和代表结束查找范围的迭代器last(注意,该查找范围并不包含last本身,即查找范围是(first,last]),以及一个待查找的元素val.如果find函数在范围中查找到了val,则返回第一个等于val的元素的迭代器,如果没有找到,则返回迭代器last.
使用find()函数查找vector中的值:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5,8,6,0,9,7 };
vector<int> v1(a, a + 10);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
vector<int>::iterator fit =find(v1.begin(), v1.end(), 8);
if (fit != v1.end())
{
cout << *fit << endl;
}
else
{
cout << "none" << endl;
}
fit = find(v1.begin(), v1.end(), 10);
if (fit != v1.end())
{
cout << *fit << endl;
}
else
{
cout << "none" << endl;
}
return 0;
}
查找结果如下:
编辑
使用find()函数查找vector对象集合中的某个元素并删除:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5,8,6,0,9,7 };
vector<int> v1(a, a + 10);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.erase( find(v1.begin(), v1.end(), 8) );
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
return 0;
}
删除结果如下:
编辑
使用find()函数查找并删除vector中多个相同的元素:
我们有时会有这样的场景,比如我们想删除下面vector中所有的元素8:
1,4,3,2,5,8,6,8,0,8,8,8,9,7
按照前面的思路,我们一定首先想到的就是将删除和查找操作写成一个循环,如:
vector<int>::iterator fit = find(v1.begin(), v1.end(), 8);
while (fit != v1.end())
{
v1.erase(fit);
fit = find(fit+1, v1.end(), 8);
}
这段代码看似没有什么问题,但实际上运行程序会造成经典的迭代器失效问题:
编辑
迭代器失效问题简单来讲,就是因为底层实现的原因,我们在erase删除fit迭代器时fit就会失效,这时候下一行再用fit+1作为find的参数来查找就会导致程序异常,对于这个问题,目前比较简单的解决方法是:
每次都从vector的最开始查找我们的目标元素,该方法的缺点是效率很低:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5,8,6,8,0,8,8,8,9,7 };
vector<int> v1(a, a + 14);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
vector<int>::iterator fit = find(v1.begin(), v1.end(), 8);
while (fit != v1.end())
{
v1.erase(fit);
fit = find(v1.begin(), v1.end(), 8);
}
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
return 0;
}
编辑
还有一种方法是,我们使用fit来接收一下erase()的返回值来更新fit的位置,因为erase返回值是"一个迭代器，指向元素的新位置，该元素紧跟在函数调用擦除的最后一个元素之后。如果操作擦除了序列中的最后一个元素，则这是容器结束。"然后再使用fit作为find的参数即可接着上一个删除的位置继续向后寻找待删除元素,代码如下:
int main()
{
//构造一个数组a
int a[] = { 1,4,3,2,5,8,6,8,0,8,8,8,9,7 };
vector<int> v1(a, a + 14);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
vector<int>::iterator fit = find(v1.begin(), v1.end(), 8);
while (fit != v1.end())
{
fit = v1.erase(fit);
fit = find(fit, v1.end(), 8);
}
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
return 0;
}
效果如下:
编辑
结语
希望这篇关于 vector对象集合简介 的博客能对大家有所帮助,欢迎大佬们留言或私信与我交流.
学海漫浩浩,我亦苦作舟!关注我,大家一起学习,一起进步!
相关文章推荐
【C++】9道 经 典面 试题带 你玩 转 string 类
【C++】 类 的六大默 认 成 员 函数及其特性 (万字 详 解 )
编辑
- 点赞
- 收藏
- 关注作者
评论（0）