【C++基础】std::vector详解

已于 2024-04-04 18:43:15 修改
阅读量6.1k 收藏 24
点赞数 36
分类专栏： C++ 文章标签： c++ 开发语言 数据结构 排序算法
于 2024-04-04 18:41:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75772333/article/details/137367814
版权
本文详细介绍了C++标准库中的std::vector容器，包括其底层实现、成员函数如迭代器操作、容量管理、元素访问、赋值与增删操作，以及构造函数、析构函数和运算符重载。同时讨论了vector在不同场景下的性能优缺点。
摘要由CSDN通过智能技术生成

std::vector 是 C++ 标准库中的一个容器，提供了动态数组的功能。它的底层实现通常是使用连续的内存块来存储元素，因此可以通过指针算术来访问元素，并且支持常数时间的随机访问，并支持在容器末尾高效地添加和删除元素。

一、底层实现

std::vector 的底层通常由一个连续的内存块（数组）来存储其元素，内部的元素在内存中是依次排列的，可以通过指针算术或迭代器进行快速的随机访问。

当 std::vector 中的元素数量超过当前容量时，std::vector 会重新分配更大的内存块，并将元素从旧的内存块复制到新的内存块中。这通常涉及到动态内存分配和释放，但由于 std::vector 使用连续的内存存储元素，因此仅需要一次连续的内存分配，这有助于提高效率。

当创建一个空的 std::vector 对象时，它不分配任何内存，大小是0。当开始添加元素时，std::vector 会动态分配内存。通常情况下，第一次分配的内存大小由具体的实现决定，但通常是一个小的初始值，比如16或32个元素大小的内存块。

当元素数量超过当前内存容量时，std::vector 将重新分配内存并将元素从旧的内存块复制到新的内存块中。新的内存块的大小通常是当前元素数量的两倍或更多，具体取决于具体的实现和策略。重新分配内存时，可能会有一些额外的内存开销，因为需要考虑到内存对齐和内存管理的一些细节。

二、成员函数

std::vector 提供了一系列成员函数来操作和管理动态数组。

1、迭代器：

begin(), end()
cbegin(), cend()
rbegin(), rend()
crbegin(), crend()

    std::vector<int> vec{1,2,3,4,5};
    std::cout<<"begin() -> end()"<<std::endl;
    for(auto it = vec.begin(); it != vec.end(); it++) {
        std::cout<<*it<<std::endl; // 1 2 3 4 5
    }
    std::cout<<"cbegin() -> cend()"<<std::endl;
    for(auto it = vec.cbegin(); it != vec.cend(); it++) {
        std::cout<<*it<<std::endl; // 1 2 3 4 5
    }
    std::cout<<"rbegin() -> rend()"<<std::endl;
    for(auto it = vec.rbegin(); it != vec.rend(); it++) {
        std::cout<<*it<<std::endl; // 5 4 3 2 1 
    }
    std::cout<<"crbegin() -> crend()"<<std::endl;
    for(auto it = vec.crbegin(); it != vec.crend(); it++) {
        std::cout<<*it<<std::endl; // 5 4 3 2 1 
    }

2、容量：

empty()
size()
max_size()
reserve(size_type new_cap)
capacity()
shrink_to_fit()

    std::vector<int> vec{1,2,3,4,5};
    std::cout<<vec.empty()<<std::endl; // 0
    std::cout<<vec.size()<<std::endl; // 5
    std::cout<<vec.max_size()<<std::endl; // 2305843009213693951
    std::cout<<vec.capacity()<<std::endl; // 5
    vec.reserve(50);
    std::cout<<vec.capacity()<<std::endl; // 50
    vec.shrink_to_fit();
    std::cout<<vec.capacity()<<std::endl; // 5

resize(size_type count)
resize(size_type count, const value_type& value)

    std::vector<int> vec{1,2,3};
    for(auto num:vec){
        std::cout<<num<<std::endl; // 1 2 3 
    }
    vec.resize(5);
    for(auto num:vec){
        std::cout<<num<<std::endl; // 1 2 3 0 0
    }

3、元素访问：

operator[]
at()
front()
back()
data()

    std::vector<int> vec{0,1,2,3,4,5};
    std::cout<<vec[3]<<std::endl; // 3
    std::cout<<vec.at(3)<<std::endl; // 3
    std::cout<<vec.front()<<std::endl; // 0
    std::cout<<vec.back()<<std::endl; // 5
    int* ptr = vec.data();
    for (size_t i = 0; i < vec.size(); ++i) {
        std::cout << *(ptr + i) << " "; // 0 1 2 3 4 5
    }

4、赋值：

4.1、assign()

    std::vector<int> vec{1,2,3,4};
    std::vector<int> vec_bak{5,6,7,8,9};
    vec.assign(vec_bak.begin(), vec_bak.end()); // 5 6 7 8 9
    for(auto num:vec){
        std::cout<<num<<std::endl;
    }
    vec.assign(4,50);
    for(auto num:vec){
        std::cout<<num<<std::endl; // 50 50 50 50
    }

4.2、swap(vector& other)

    std::vector<int> vec{1,2,3,4};
    std::vector<int> vec_bak{5,6,7,8,9};
    vec.swap(vec_bak);
    for(auto num:vec){
        std::cout<<num<<std::endl; // 5 6 7 8 9
    }
    for(auto num:vec_bak){
        std::cout<<num<<std::endl; // 1 2 3 4 
    }

5、尾部增删：

push_back(const T& value)
push_back(T&& value)
pop_back()
emplace_back(Args&&... args)

    std::vector<std::string> vec{"A","B","C"};
    for(auto num:vec){
        std::cout<<num<<std::endl; // A B C
    }
    vec.push_back("D");
    for(auto num:vec){
        std::cout<<num<<std::endl; // A B C D
    }
    vec.pop_back();
    for(auto num:vec){
        std::cout<<num<<std::endl; // A B C
    }
    vec.emplace_back(std::move("E"));
    for(auto num:vec){
        std::cout<<num<<std::endl; // A B C E
    }

PS：如果是普通元素则一样，如果元素是对象则有区别。
push_back：添加的对象是一个左值，进行深拷贝。添加的对象是右值且有移动构造函数，执行移动操作。
emplace_back:它不会执行深拷贝或移动操作,根据参数直接调用构造新的对象。

Demo ： push_back 和 emplace_back 演示

#include <iostream>
#include <vector>

class MyObject {
public:
    MyObject(int value) : value_(value) {
        std::cout << "Constructing MyObject with value: " << value_ << std::endl;
    }

    MyObject(const MyObject& other) {
        value_ = other.value_;
        std::cout << "Copying MyObject with value: " << value_ << std::endl;
    }

    MyObject(MyObject&& other) noexcept {
        value_ = other.value_;
        other.value_ = 0;  // Reset the value of the moved object
        std::cout << "Moving MyObject with value: " << value_ << std::endl;
    }

    int getValue() const {
        return value_;
    }

private:
    int value_;
};

int main() {
    std::vector<MyObject> vec;

    // 使用 push_back 添加已构造好的对象
    MyObject obj1(10);
    vec.push_back(obj1); // 调用拷贝构造函数
    vec.push_back(MyObject(20)); // 直接通过临时对象构造新元素，调用移动构造函数

    std::cout << "Vector size after push_back: " << vec.size() << std::endl;

    // 使用 emplace_back 直接在容器内构造新对象
    vec.emplace_back(30); // 直接在容器内构造新元素，调用构造函数
    vec.emplace_back(40); // 直接在容器内构造新元素，调用构造函数

    std::cout << "Vector size after emplace_back: " << vec.size() << std::endl;

    return 0;
}

6、随机增删

6.1、insert
用于在指定位置插入一个或多个元素。其函数签名为：

iterator insert (const_iterator position, const T& value);
iterator insert (const_iterator position, T&& value);
iterator insert (const_iterator position, size_type n, const T& value);
template <class InputIterator>
iterator insert (const_iterator position, InputIterator first, InputIterator last);
iterator insert (const_iterator position, initializer_list<T> il);

第一个版本在指定位置插入一个值为 value 的元素。
第二个版本在指定位置插入一个右值引用 value 的元素。
第三个版本在指定位置插入 n 个值为 value 的元素。
第四个版本在指定位置插入从迭代器范围 [first, last) 的元素。
第五个版本在指定位置插入初始化列表 il 中的元素。
insert 函数返回一个迭代器，指向插入的第一个元素。
Demo：使用 insert 函数向 std::vector 插入元素：

    std::vector<int> vec{1,2,3,4,5};
    for(auto num : vec) {
        std::cout<<num<<std::endl; // 1 2 3 4 5
    }
    auto it = vec.insert(vec.begin()+2,10);
    std::cout<<*it<<std::endl; // 10
    for(auto num : vec) {
        std::cout<<num<<std::endl; // 1 2 10 3 4 5
    }
    vec.insert(vec.begin(),3,30);
    for(auto num : vec) {
        std::cout<<num<<std::endl; // 30 30 30 1 2 10 3 4 5
    }
    std::vector<int> another = {100,200,300};
    vec.insert(vec.end(),another.begin(),another.end());
    for(auto num : vec) {
        std::cout<<num<<std::endl; // 30 30 30 1 2 10 3 4 5 100 200 300 
    }
    vec.insert(vec.begin(),{-2,-1});
    for(auto num : vec) {
        std::cout<<num<<std::endl; // -2 -1 30 30 30 1 2 10 3 4 5 100 200 300 
    }

6.2、 emplace
用于在向量中指定位置插入一个元素。与 insert 函数不同，emplace 函数可以直接在向量中就地构造新元素，而不需要提前创建一个对象。emplace 函数的参数用于构造新元素的构造函数参数。
它有两种重载形式：
iterator emplace(const_iterator position, Args&&... args)：在指定位置插入一个新元素，并将构造函数参数传递给元素类型的构造函数。
void emplace_back(Args&&... args)：在向量末尾插入一个新元素，并将构造函数参数传递给元素类型的构造函数。
Demo：emplace函数演示

#include <iostream>
#include <vector>

class MyClass {
public:
    MyClass(int val) : value(val) {
        std::cout << "Constructor called with value: " << val << std::endl;
    }

private:
    int value;
};

int main() {
    std::vector<MyClass> vec;

    // 在向量末尾插入一个新元素
    vec.emplace_back(10);

    // 在向量的第一个位置插入一个新元素
    vec.emplace(vec.begin(), 20);

    return 0;
}

6.3、erase
用于从向量中删除一个或多个元素。
它有两个重载形式：
iterator erase(iterator position)：从向量中删除指定位置的元素，并返回指向删除元素之后的元素的迭代器。
iterator erase(iterator first, iterator last)：从向量中删除指定范围内的元素，并返回指向删除范围之后的元素的迭代器。
Demo：演示两种erase

    std::vector<int> vec{1,2,3,4,5};
    for(auto num : vec) {
        std::cout<<num<<std::endl; // 1 2 3 4 5
    }
    vec.erase(vec.begin()+2);
    for(auto num : vec) {
        std::cout<<num<<std::endl; // 1 2 4 5
    }
    vec.erase(vec.begin(),vec.begin()+2);
    for(auto num : vec) {
        std::cout<<num<<std::endl; // 4 5
    }

6.4、clear

用于清空向量，即移除向量中的所有元素，使其成为空向量。
该函数没有返回值，调用后向量的大小变为0，但是向量仍然保留了一部分内存空间，以备后续添加元素时使用。

    std::vector<int> vec{1,2,3,4,5};
    std::cout<<vec.size()<<" "<<vec.capacity()<<std::endl; // 5 5
    vec.clear();
    std::cout<<vec.size()<<" "<<vec.capacity()<<std::endl; // 0 5

7、查找排序

std::find 和 std::sort 函数来执行查找和排序操作。

std::find 函数用于在向量中查找特定值，并返回指向找到的元素的迭代器，如果未找到，则返回尾后迭代器。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    auto it = std::find(vec.begin(), vec.end(), 3);
    if (it != vec.end()) {
        std::cout << "Found element: " << *it << std::endl; // Found element: 3
    } else {
        std::cout << "Element not found" << std::endl;
    }
    return 0;
}

std::sort 函数用于对向量中的元素进行排序，默认是升序排序。
Demo1：自定排序规则

struct MyStruct {
    int id;
    std::string name;
};

bool compareByName(const MyStruct& a, const MyStruct& b) {
    return a.name < b.name;
}

int main() {
    std::vector<MyStruct> vec = {
        {1, "John"},
        {2, "Alice"},
        {3, "Bob"}
    };
    std::sort(vec.begin(), vec.end(), compareByName);

    // ID: 2, Name: Alice
    // ID: 3, Name: Bob
    // ID: 1, Name: John
    for (const auto& item : vec) {
        std::cout << "ID: " << item.id << ", Name: " << item.name << std::endl;
    }
    return 0;
}

Demo2：逆序排序

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {5, 2, 8, 1, 6};

    // 使用 lambda 表达式定义自定义比较函数，实现逆序排序
    std::sort(vec.begin(), vec.end(), [](int a, int b) {
        return a > b; // 逆序排序
    });

    // 打印逆序排序后的结果
    for (const auto& item : vec) {
        std::cout << item << " "; // 8 6 5 2 1
    }
    std::cout << std::endl;

    return 0;
}

三、构造函数与析构函数

1、构造函数：
vector()：构造一个空的 vector。
vector(size_type count, const T& value)：构造一个包含 count 个元素，每个元素的值都是 value 的 vector。

std::vector<int> vec1;
std::vector<std::string> vec2(5,"A");

vector(const vector& other)：拷贝构造函数，深拷贝，会复制 other 中的元素，并将它们存储在新的内存位置

#include <iostream>
#include <vector>

int main() {
    std::vector<int> original = {1, 2, 3, 4, 5};
    
    // 使用拷贝构造函数创建一个新的 vector
    std::vector<int> copy(original);
    
    // 输出原始 vector
    std::cout << "Original vector: ";
    for (int num : original) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    // 输出拷贝后的 vector
    std::cout << "Copied vector: ";
    for (int num : copy) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

vector(vector&& other) noexcept：移动构造函数，将另一个已存在的 vector 对象的资源“移动”到新创建的 vector 中，而不是进行深拷贝。

这里 other 是另一个 vector 对象的右值引用，表示要移动的源对象。移动构造函数会将 other 中的资源（例如指向内存块的指针）转移给新创建的 vector，并使 other 保持有效但处于有效但无法访问的状态。移动构造函数的主要目的是提高性能，因为它避免了不必要的资源复制。

#include <iostream>
#include <vector>

int main() {
    // 创建一个临时 vector
    std::vector<int> temp = {1, 2, 3, 4, 5};
    
    // 使用移动构造函数创建一个新的 vector
    std::vector<int> moved(std::move(temp));
    
    // 输出原始 vector
    std::cout << "Original vector: ";
    for (int num : temp) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    // 输出移动后的 vector
    std::cout << "Moved vector: ";
    for (int num : moved) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

2、析构函数：
~vector() noexcept：析构函数负责释放其管理的所有元素，并释放动态分配的内存。具体来说，析构函数会调用每个元素的析构函数，然后释放分配给动态数组的内存。

在 C++ 标准库中，std::vector 的析构函数是隐式生成的，如果用户没有自定义，将会使用编译器默认生成的析构函数。默认情况下，析构函数会按顺序释放元素，然后释放分配的内存。因此，std::vector 在其生命周期结束时会自动执行析构函数，确保动态分配的内存被正确释放，从而避免内存泄漏。

四、运算符重载

[] 运算符：用于访问向量中指定位置的元素，例如 vec[i]。
== 和 != 运算符：用于比较两个向量是否相等或不相等。
<, <=, >, >= 运算符：用于比较两个向量的大小关系，通常是按字典序比较。

    std::vector<int> vec = {1, 2, 3};
    std::cout<<vec[1]<<std::endl; // 2
    std::vector<int> vec1 = {1, 2, 3};
    std::cout<<(vec == vec1)<<std::endl; // 1
    std::cout<<(vec != vec1)<<std::endl; // 0
    std::vector<int> vec2 = {1, 2, 4};
    std::cout<<(vec2 > vec1)<<std::endl; // 1

五、vector的性能问题

1、随机访问: std::vector 支持通过索引进行 O(1) 时间复杂度的随机访问。这是因为 std::vector 内部使用连续的内存存储元素，因此可以通过指针算术运算来快速访问元素。

2、尾部插入和删除: 在尾部进行插入和删除操作是非常高效的，平均时间复杂度为 O(1)。因为 std::vector 内部的元素是连续存储的，所以在尾部插入或删除元素只需要修改指向尾部的指针，不需要移动其他元素。

3、中间插入和删除: 在中间位置插入或删除元素可能会导致后续元素的移动，因此平均时间复杂度为 O(n)。如果需要在中间位置频繁地进行插入或删除操作，考虑使用 std::deque 或 std::list 等数据结构。

4、内存管理: std::vector 会自动管理内存，动态地分配和释放内存以存储元素。当元素数量超过当前分配的内存空间时，std::vector 会自动重新分配更大的内存空间，并将原有元素复制到新的内存空间中。这种动态内存管理可能会导致插入操作的时间复杂度增加。

5、预留空间: std::vector 允许预留一定的空间，以避免频繁的内存重新分配。通过调用 reserve 函数可以预先分配一定大小的内存空间，从而减少插入操作的时间复杂度。

6、迭代器: std::vector 提供了双向迭代器和随机访问迭代器，可以高效地遍历元素。

std::vector 是一个高效的动态数组容器，特别适用于需要随机访问和尾部插入删除的场景。
然而，在频繁进行中间插入和删除操作时，可能会影响性能，因此需要根据实际需求选择合适的容器类型。

kucupung
关注
专栏目录
C++——STL之vector详解
weixin_59055853的博客
12-21 1880
学习了string之后，学习其他模板将会更容易上手，一起来看一下vector吧！vector是表示大小可以变化的数组的序列容器。
C++ 中的 std::vector：动态数组操作和常用函数解析
南城小馆
11-15 5819
C++ 中的 std::vector 是一个非常实用的容器，它提供了动态大小的数组功能，可以存储任意类型的元素，并且可以方便地进行元素的添加、删除和查询操作。本博客不仅介绍了一些常用的成员函数和操作符，如 push_back()、pop_back()、size()、empty() 和 clear()，还详细对比了 push_back() 和 emplace_back() 之间的区别。此外，博客还提供了一些小示例程序，以帮助读者更好地理解这些概念。
C++ VECTOR
最新发布
wangxu696200的博客
09-27 586
在 C++ 中，是标准库提供的一个容器类，用于存储动态大小的元素序列（即"动态数组"）。它提供了一系列成员函数和操作符，使得元素的访问、插入、删除等操作变得方便和高效。数组适用于大小固定且事先知道元素数量的情况下使用，尤其是数据集较小或需要静态分配内存的场景。vector适用于大小可变的情况，特别是需要动态增长或缩小的场景，并且具有更多的功能和灵活性。
【C++】STL —— vector基本使用
M的博客
06-08 2648
vector常用接口一张思维导图帮你总结
【C++】std::vector源码浅析
Making Life Better. Making Others Better.
12-03 8152
std::vector是stl标准模板库中的一个序列容器，其源码实现有几个特点：（1）C++中include的标准头文件是没有“.h”后缀的，其实这是C++的一层包裹，内部实现还是在“.h”文件中完成的，以我们include的vector为例，其中还会include一些真正的vector实现文件，如“stl_vector.h”。（2）vector的实现有一些内部使用的函数和数据类型，它们以下划线“_
std::vector排序详解
10-09
一个详细全面的关于vector排序的例子。 涉及到 如何继承std::binary_function、如何重载operator().
C++ —— std vector
老友不要辣的博客
10-26 1059
std::vector变量名(容器个数, 初始化的值);
[C++] std::vector
weixin_55664293的博客
05-30 5130
std::vector template < class T, class Alloc = allocator<T> > class vector; // generic template vector是表示可以改变大小的数组的序列容器。 就像数组一样，向量对其元素使用连续的存储位置，这意味着也可以使用指向其元素的常规指针上的偏移量来访问它们的元素，并且与在数组中一样有效。但与数组不同的是，它们的大小可以动态变化，它们的存储由容器自动处理。 在内部，向量使用动态分配的数组来
c++ std::vector
肥猫王德福的博客
11-17 2122
single element (1) iterator insert (const_iterator position, const value_type& val); fill (2) iterator insert (const_iterator position, size_type n, const value_type& val); range (3) template <class InputIterator> iterator insert (cons
std::vector介绍
热门推荐
armman的专栏
02-04 6万+
vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。为了可以使用vector，必须在你的头文件中包含下面的代码：#include vector属于std命名域的，因此需要通过命名限
C++11中lambda、std::function和std:bind详解
08-31
std::vector<int> numbers { /*...*/ }; for_each(numbers.begin(), numbers.end(), [](int i) { if (i % 5 == 0 || i > 20) { std::cout << i << std::endl; } }); ``` **std::function**是C++11标准库中的一...
C++线程库std::thread和std::async的用法详解
程序猿老樊的博客
05-26 915
C++作为一门强大的系统编程语言，提供了多种并发编程工具，使得开发者可以充分利用多核处理器的性能。C++11标准引入了新的线程库，包括std::thread和std::async，为开发高效并发应用提供了强大支持。下面我将std::thread和std::async的用法及其原理做一个归纳总结，希望对大家有帮助。
C++ std::vector容器使用详解
std vector 用法详解 std::vector 是 C++ 标准模板库中的一个多功能的容器类，它能够存放各种类型的对象，是一个能够存放任意类型的动态数组，能够增加和压缩数据。std::vector 是一个模板类和函数库，可以操作多种...
android jni中使用std::vector
安卓兼职framework和app工程师的博客
11-02 2008
在jni开发中 std::vector可以理解为动态数组，其特点和基本操作方式与array相似，但vector可以动态调整大小。 vector中的元素是连续存储的，这意味着我们不仅可以通过迭代器std::vector::iterator，还可以像array一样使用下标来访问任意位置的元素。 它和c++中的用法一样的 现在就用jni来写个案例来实现使用std:vector 案例如下: 头文件 Study_One.h #ifndef JNITEST_STUDY_ONE_H #define JNITEST_STU
C++ STL中的std::remove_if 的用法详解
程序员黄老师的精品课！
07-15 327
是C++ STL中头文件的一部分，它用于从容器中移除所有满足给定谓词（即判断条件）的元素。值得注意的是，并不会直接删除元素，而是将不满足条件的元素移到容器的前面，返回一个新的迭代器指向第一个应被删除的元素。因此，为了完全删除这些元素，我们需要配合容器的erase成员函数使用。假设我们有一个Student类，包含姓名、年龄和成绩等属性，我们的目标是从一个中移除所有成绩低于60分的学生。首先，定义Studentpublic:int score;// 用于输出学生信息int main()
C++ std::vector
休息一下接着来的博客
07-31 823
标准库类型vector表示对象集合，其中所有的对象的类型都相同。vector常常被称为容器（container）。使用vector时，需要引入对应的头文件。vector本质上是一个类模板。 #include <vector> // 包含对应的头文件 using std::vector 1. vector的定义和初始化 vector<T> v1; // v1 是一个空vector，它潜在的元素是T类型，执行默认初始化 vector<T> V2(V1); //
深入解析C++标准库中的std::vector容器
m0_72877724的博客
06-29 1414
底层是一个动态数组，内存由动态分配的连续内存块管理。缺点内存必须连续，可能导致大容量时内存分配失败。中间插入/删除操作开销较大。优点支持随机访问。动态增长，摊销插入时间复杂度为 O(1)。使用场景适合频繁访问和遍历，以及主要在末尾进行插入/删除操作的场景。
C++的std::vector
xiaofeixia002X的博客
02-20 517
是C++标准库中的一个，它。允许你在运行时，自动管理存储空间的分配和释放。由于其灵活性和易用性，在C++程序中被广泛使用，特别是在需要存储一系列元素时。
C++之std::vector
Luck-Dream的博客
02-28 949
resize(size_type count): 更改 vector 的大小，使其包含 count 个元素。的元数据存储在栈区，而实际的元素数组存储在堆区，并且数组的大小是根据需要动态改变的。使用场景：适用于元素结构简单，变化小，并且频繁随机访问但不需要对头部和中间元素进行添加删除操作的场景。//5个元素的数组，且初始化值为1。//在itr的位置插入两个99。//在itr的位置插入元素88。缺点：在头部和中间插入删除元素需要移动内存，效率低；//查找特定的迭代器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值