1.std::vector
学习文档:https://cplusplus.com/reference/vector/vector/
- vector是表示可变大小数组的序列容器。
- 就像数组一样,vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问,和数组一样高效。但是又不像数组,它的大小是可以动态改变的,而且它的大小会被容器自动处理。
- 本质讲,vector使用动态分配数组来存储它的元素。当新元素插入时候,这个数组需要被重新分配大小为了增加存储空间。其做法是,分配一个新的数组,然后将全部元素移到这个数组。就时间而言,这是一个相对代价高的任务,因为每当一个新的元素加入到容器的时候,vector并不会每次都重新分配大小。
- vector分配空间策略:vector会分配一些额外的空间以适应可能的增长,因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何,重新分配都应该是对数增长的间隔大小,以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
- 因此,vector占用了更多的存储空间,为了获得管理存储空间的能力,并且以一种有效的方式动态增长。
- 与其它动态序列容器相比(deques, lists and forward_lists), vector在访问元素的时候更加高效,在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作,效率更低。比起lists和forward_lists统一的迭代器和引用更好。
2.vector常用接口
-
vector() 无参构造
// 无参构造函数
std::vector<int> v1;
std::cout << "v1 size: " << v1.size() << std::endl; // 输出:v1 size: 0
-
vector(size_type n, const value_type& val = value_type()) 构造并初始化n个val
// 指定大小和初始值的构造函数
std::vector<int> v2(5, 10); // 创建一个包含5个元素,每个元素值为10的vector
std::cout << "v2 elements: ";
for (int i : v2) std::cout << i << " "; // 输出:10 10 10 10 10
std::cout << std::endl;
-
vector (const vector& x); 拷贝构造
// 拷贝构造函数
std::vector<int> v3(v2); // 创建一个与v2相同的vector
std::cout << "v3 elements: ";
for (int i : v3) std::cout << i << " "; // 输出:10 10 10 10 10
std::cout << std::endl;
-
vector (InputIterator first, InputIterator last); 使用迭代器进行初始化构造
// 使用迭代器的构造函数
std::vector<int> v4(v2.begin(), v2.end()); // 使用v2的元素创建v4
std::cout << "v4 elements: ";
for (int i : v4) std::cout << i << " "; // 输出:10 10 10 10 10
std::cout << std::endl;
-
begin()获取第一个数据位置的iterator/const_iterator, end()获取最后一个数据的下一个位置的iterator/const_iterator
std::cout << "Using iterator: ";
for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
std::cout << *it << " ";
}
std::cout << std::endl;
// 使用const_iterator遍历
std::cout << "Using const_iterator: ";
for (std::vector<int>::const_iterator it = v.begin(); it != v.end(); ++it) {
std::cout << *it << " ";
}
std::cout << std::endl;
-
rbegin() 获取最后一个数据位置的reverse_iterator, rend() 获取第一个数据前一个位置的reverse_iterator
std::vector<int> v = {1, 2, 3, 4, 5};
// 使用reverse_iterator反向遍历
std::cout << "Using reverse_iterator: ";
for (std::vector<int>::reverse_iterator rit = v.rbegin(); rit != v.rend(); ++rit) {
std::cout << *rit << " ";
}
std::cout << std::endl;
// 使用const_reverse_iterator反向遍历
std::cout << "Using const_reverse_iterator: ";
for (std::vector<int>::const_reverse_iterator rit = v.rbegin(); rit != v.rend(); ++rit) {
std::cout << *rit << " ";
}
std::cout << std::endl;
-
size 获取数据个数
std::vector<int> vec = {1, 2, 3, 4};
std::cout << "Size: " << vec.size() << std::endl; // 输出:Size: 4
-
capacity 获取容量大小
std::vector<int> vec;
vec.reserve(10);
std::cout << "Capacity: " << vec.capacity() << std::endl; // 输出:Capacity: 10
-
empty 判断是否为空
std::vector<int> vec;
if (vec.empty()) {
std::cout << "Vector is empty" << std::endl;
}
-
resize 改变vector的size
void resize(size_type n);
将vector
的大小调整为n
,多出来的元素使用默认构造函数初始化。void resize(size_type n, const value_type& val);
将vector
的大小调整为n
,多出来的元素使用val
初始化。- resize在开空间的同时还会进行初始化,影响size。
std::vector<int> vec = {1, 2, 3};
vec.resize(5, 10); // vec 现在包含 [1, 2, 3, 10, 10]
-
reserve 改变vector的capacity
为 vector
预留至少 n 个元素的存储空间。如果 n
大于当前的 capacity()
,则分配新的内存,否则什么也不做。reserve只负责开辟空间,如果确定知道需要用多少空间,reserve可以缓解vector增容的代价缺陷问题。
std::vector<int> vec;
vec.reserve(10); // 预留空间,capacity 将至少为 10
std::cout << "Capacity: " << vec.capacity() << std::endl; // 输出:Capacity: 10
-
push_back 尾插
std::vector<int> vec;
vec.push_back(10); // vec 现在包含 [10]
vec.push_back(20); // vec 现在包含 [10, 20]
-
pop_back 尾删
std::vector<int> vec = {10, 20, 30};
vec.pop_back(); // vec 现在包含 [10, 20]
-
find 查找。(注意这个是算法模块实现,不是vector的成员接口)
#include <vector>
#include <algorithm>
std::vector<int> vec = {10, 20, 30};
auto it = std::find(vec.begin(), vec.end(), 20);
if (it != vec.end()) {
std::cout << "Found: " << *it << std::endl;
}
-
insert 在position之前插入val
std::vector<int> vec = {10, 30};
vec.insert(vec.begin() + 1, 20); // vec 现在包含 [10, 20, 30]
-
erase 删除position位置的数据
erase
操作后,返回一个新的有效迭代器 pos
,该迭代器指向被删除元素后的下一个位置。
std::vector<int> vec = {10, 20, 30};
vec.erase(vec.begin() + 1); // vec 现在包含 [10, 30]
-
swap 交换两个vector的数据空间
std::vector<int> vec1 = {10, 20};
std::vector<int> vec2 = {30, 40};
vec1.swap(vec2); // vec1 现在包含 [30, 40], vec2 包含 [10, 20]
-
operator[] 像数组一样访问
std::vector<int> vec = {10, 20, 30};
int val = vec[1]; // val 为 20
vec[1] = 25; // vec 现在包含 [10, 25, 30]
-
assign(size_type count, const T& value)给向量(
vector
)中的元素重新赋值
//1.用指定数量的相同元素重新赋值整个向量。
std::vector<int> v;
v.assign(5, 10); // v 现在包含 5 个值为 10 的元素
//2.用一个迭代器区间内的元素来重新赋值整个向量。
std::vector<int> v1 = {1, 2, 3, 4, 5};
std::vector<int> v2;
v2.assign(v1.begin(), v1.end()); // v2 现在包含 v1 中的所有元素
//3.用初始化列表中的元素重新赋值整个向量.
std::vector<int> v;
v.assign({1, 2, 3, 4, 5}); // v 现在包含 1, 2, 3, 4, 5
-
vector的三种遍历方式
//1.传统的 for 循环
int main() {
std::vector<int> vec = {10, 20, 30, 40, 50};
for (size_t i = 0; i < vec.size(); ++i) {
std::cout << vec[i] << " ";
}
std::cout << std::endl;
return 0;
}
//2.范围 for 循环(C++11)
int main() {
std::vector<int> vec = {10, 20, 30, 40, 50};
for (int val : vec) {
std::cout << val << " ";
}
std::cout << std::endl;
return 0;
}
//3.使用迭代器遍历
#include <iostream>
#include <vector>
int main() {
std::vector<int> vec = {10, 20, 30, 40, 50};
for (auto it = vec.begin(); it != vec.end(); ++it) {
std::cout << *it << " ";
}
std::cout << std::endl;
return 0;
}
//3.使用反向迭代器
#include <iostream>
#include <vector>
int main() {
std::vector<int> vec = {10, 20, 30, 40, 50};
for (auto rit = vec.rbegin(); rit != vec.rend(); ++rit) {
std::cout << *rit << " ";
}
std::cout << std::endl;
return 0;
}
3.vector迭代器失效问题
迭代器的主要作用就是让算法能够不用关心底层数据结构,其底层实际就是一个指针,或者是对指针进行了封装,比如:vector的迭代器就是原生态指针T*。因此迭代器失效,实际就是迭代器底层对应指针所指向的空间被销毁了,而使用一块已经被释放的空间,造成的后果是程序崩溃(即如果继续使用已经失效的迭代器,程序可能会崩溃)。
3.1. 引起其底层空间改变的操作,比如:resize、reserve、insert、assign、push_back等。
#include <iostream>
using namespace std;
#include <vector>
int main()
{
vector<int> v{1,2,3,4,5,6};
auto it = v.begin();
// 将有效元素个数增加到100个,多出的位置使用8填充,操作期间底层会扩容
// v.resize(100, 8);
// reserve的作用就是改变扩容大小但不改变有效元素个数,操作期间可能会引起底层容量改变
// v.reserve(100);
// 插入元素期间,可能会引起扩容,而导致原空间被释放
// v.insert(v.begin(), 0);
// v.push_back(8);
// 给vector重新赋值,可能会引起底层容量改变
v.assign(100, 8);
/*
出错原因:以上操作,都有可能会导致vector扩容,也就是说vector底层原理旧空间被释放掉,
而在打印时,it还使用的是释放之间的旧空间,在对it迭代器操作时,实际操作的是一块已经被释放的
空间,而引起代码运行时崩溃。
解决方式:在以上操作完成之后,如果想要继续通过迭代器操作vector中的元素,只需给it重新
赋值即可。
*/
while(it != v.end())
{
cout<< *it << " " ;
++it;
}
cout<<endl;
return 0;
}
3.2. 指定位置元素的删除操作--erase
#include <iostream>
using namespace std;
#include <vector>
int main()
{
int a[] = { 1, 2, 3, 4 };
vector<int> v(a, a + sizeof(a) / sizeof(int));
// 使用find查找3所在位置的iterator
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
// 删除pos位置的数据,导致pos迭代器失效。
v.erase(pos);
cout << *pos << endl; // 此处会导致非法访问
return 0;
}
erase删除pos位置元素后,pos位置之后的元素会往前搬移,没有导致底层空间的改变,理论上讲迭代器不应该会失效,但是:如果pos刚好是最后一个元素,删完之后pos刚好是end的位置,而end位置是没有元素的,那么pos就失效了。因此删除vector中任意位置上元素时,vs就认为该位置迭代器失效了。
迭代器失效解决办法:在使用前,对迭代器重新赋值即可。
int main()
{
std::vector<int> v{ 1, 2, 3, 4 };
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
v.erase(it); //erase操作使得it失效,++it 可能会访问不安全的内存或导致程序崩溃。
++it;
}
return 0;
}
int main()
{
std::vector<int> v{ 1, 2, 3, 4 };
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
it = v.erase(it); // 更新迭代器,保证在删除元素后,迭代器始终指向一个有效的位置,并避免迭代器失效的问题。
else
++it;
}
return 0;
}