C++入门——07vector

于 2024-08-18 15:35:51 发布
阅读量538 收藏 14
点赞数 8
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56989421/article/details/141288994
版权

1.std::vector

学习文档：https://cplusplus.com/reference/vector/vector/

  1. vector是表示可变大小数组的序列容器。
  2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
  3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
  4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
  5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
  6. 与其它动态序列容器相比（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;
}

木木没有哒
关注
  • 8
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++之vector深度剖析
aaaaauaan的博客
11-03 2717
C++之vector深度剖析1.vector的介绍及使用1.1 vector的介绍1.2 vector的使用1.2.1 vector的定义1.2.2 vector iterator 的使用1.2.3 vector 空间增长问题1.2.3 vector 增删查改1.2.4 vector 迭代器失效问题2.vector深度剖析及模拟实现 1.vector的介绍及使用 1.1 vector的介绍 vector是表示可变大小数组的序列容器。 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可
C++ vector用法
04-27 1737
在c++中，vector是一个十分有用的容器，下面对这个容器做一下总结。 1 基本操作 (1)头文件#include<vector>. (2)创建vector对象，vector<int> vec; (3)尾部插入数字：vec.push_back(a); (4)使用下标访问元素，cout<<vec[0]<<endl;记住下标是从0开...
【C++语言】vector的介绍与使用
风铃子加油的博客
07-24 1155
1. vector是表示可变大小数组的序列容器。 2.就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。3.本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小，为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。
c++ vector 用法总结
cindywry的博客
08-03 2万+
vector 是向量类型，它可以容纳许多类型的数据，如若干个整数，所以称其为容器。vector 是C++ STL的一个重要成员，使用它时需要包含头文件：#include&lt;vector&gt;; 一、vector 的初始化：可以有五种方式,举例说明如下： (1) vector&lt;int&gt; a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类...
vecto迭代器失效
weixin_53831496的博客
08-09 341
迭代器失效 迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T*。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。 对于vector可能会导致其迭代器失效的操作有： 会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。
C++——vector
Ll_R_lL的博客
09-29 7116
vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是。
C++ 向量(vector)
lisayh的博客
02-15 8204
1.向量vector简介 向量 vector 是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。 与string相同, vector 同属于STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型, 可以广义上认为是数组的增强版。      在使用它时, 需要包含头文件 vector, #include&lt;vector&gt;  ...
【C++】STL--vector
qq_48460693的博客
04-06 1262
C++中，vector是一个模版，第一个参数是类型T，第二个参数暂且不考虑。我们可以通过上面这句代码将参数T给成int，那么vector中所包含的元素就是int。（重点）1.vector()无参构造（重点）2.vector (const vector& x)拷贝构造构造并初始化n个val使用迭代器进行初始化构造。
c++ vector
tiankongtiankong01的博客
05-23 833
c++ std vector用法介绍2016年07月05日 17:24:34阅读数：10380 c++ vector一部分内容来自：http://blog.csdn.net/phoebin/article/details/3864590；http://www.cnblogs.com/wang7/archi...
vector详解(C++)
加麻加辣不加糖醋的博客
01-12 1万+
1.push_back 在数组的最后添加一个数据2.pop_back 去掉数组的最后一个数据3.at 得到编号位置的数据4.begin 得到数组头的指针5.end 得到数组的最后一个单元+1的指针6.front 得到数组头的引用7.back 得到数组的最后一个单元的引用8.max_size 得到vector最大可以是多大9.capacity 当前vector分配的大小10.size 当前使用数据的大小11.resize 改变当前使用数据的大小，如果它比当前使用的大，者填充默认值。
C++中的vector
githubcurry
08-08 387
一、向量的介绍   向量 vector 是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。与string相同, vector 同属于STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型, 可以广义上认为是数组的增强版;   在使用它时，需要包含vector头文件，#include< vector >；   vector 容器与数组相比其优点在于它能够根据需要随时自动调整自身的大小以便容下所要放入的元素。此外, vector 也提供
C++ vector
12-15
C++ vector,初学的适合看，入门用的
C++ 向量（vector）
february_的博客
12-06 9157
1. vector介绍 向量 vector 是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。 与string相同, vector 同属于STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型, 可以广义上认为是数组的增强版 ,与数组相比，vector就是一个可以不用再初始化就必须制定大小的边长数组，当然了，它还有许多高级功能。 ...
C++的vector类
最新发布
2302_80190394的博客
08-03 983
C++的vector学习
C++ Vector
ms_cplusplus的博客
08-20 377
vector的使用频率非常高，因此应该很好的掌握vector。 vector是标准库类型，表示对象的集合，其中所有对象的类型都相同。集合中的每个对象都有一个与之对应的索引，索引用于访问对象。 1、使用vector需要包含的头文件及声明： #include<vector> using std::vector; 2、定义和初始化vector对象 vector < T > v1...
C++ 中vector的使用方法
热门推荐
那年聪聪
02-01 35万+
C++ 中vector的使用方法(纯干货！)
C++vector类
weixin_44614083的博客
04-26 2593
系列文章目录 文章目录系列文章目录一、vector是什么？二、常用接口说明1.常见的构造函数2.vector iterator的使用3.关于vector的容量4.vector的增删改查2.读入数据总结 一、vector是什么？ vector是表示可变大小数组的序列容器，类似于数组，vector也采用连续的存储空间来存储元素。这就意味之可以通过下标对vector中元素进行随机访问。同时，其大小是可以动态改变的，会被容器自动处理。 本质上讲，vector使用动态内存分配数组来存储它的元素。当新元素插入时，这
[c++基础]-vector类
分享技术
11-30 6262
本期学习目标: 了解vector类的基本用法，刨析迭代器失效问题，刨析深浅拷贝问题，模拟实现vector。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值