C++ vector

于 2024-08-26 22:34:48 发布
阅读量591 收藏 28
点赞数 7
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51753728/article/details/141470777
版权

1. 引言

1.1 vector的重要性及其在C++标准库中的地位

std::vector 是C++标准库中最常用和最重要的容器之一。它是一个动态数组，可以在运行时根据需要自动调整其大小。vector 提供了一种方便、高效的方法来管理连续存储的数据，使得开发者能够轻松处理动态大小的数据集合。

std::vector 的重要性

  • 动态大小：std::vector 能够根据元素的增加或删除自动调整其大小。与C语言中的数组相比，vector 不需要开发者手动管理内存，也不会导致缓冲区溢出或内存泄漏等问题。

  • 连续内存布局：std::vector 在内存中存储元素时采用连续的内存块。这不仅提高了缓存的效率，还支持快速的随机访问（O(1)时间复杂度），使其适合需要高效索引的场景。

  • 丰富的功能：std::vector 提供了丰富的成员函数，可以轻松地对数据进行插入、删除、排序等操作。它还支持迭代器，使得vector 与标准模板库（STL）的其他组件无缝集成。

  • 异常安全性：std::vector 在进行增删操作时，如果发生异常（例如内存分配失败），它会自动回滚到操作之前的状态，从而确保程序的稳定性。

  • 强大的扩展性：std::vector 可以用于不同的数据类型（包括自定义类型），并且能够通过指定分配器来定制其内存管理策略。这种灵活性使vector 能够适应各种复杂的应用场景。

std::vector 在C++标准库中的地位

std::vector 是C++标准库中的核心容器之一，具有如下关键地位：

  1. 标准库的默认选择：在大多数需要动态数组的场景下，std::vector 是默认的选择。它的设计使得它可以在绝大多数情况下替代C风格的数组，同时提供了更好的安全性和功能。

  2. 广泛使用：由于std::vector 的灵活性和高效性，它在C++程序中被广泛使用。无论是小型项目还是大型系统，std::vector 都是处理动态数据的首选。

  3. 支持泛型编程：std::vector 是一个模板类，可以存储任何类型的对象。这使得它在泛型编程中发挥了重要作用，可以与其他STL算法和容器互操作。

  4. 性能优化：由于std::vector 在内存管理和访问速度上的优势，它在性能敏感的应用中也非常流行。此外，标准库对vector 的实现通常进行了高度优化，确保了其在不同平台上的高效性。

总的来说，std::vector 是C++标准库中不可或缺的一部分，其功能的丰富性、性能的高效性以及易用性使其成为处理动态数据的最佳工具之一。

1.2 为什么选择使用vector而不是传统的数组

选择使用std::vector而不是传统的C风格数组主要基于以下几个原因：

1. 动态大小管理

传统的C数组大小在声明时必须固定，无法在运行时调整。如果需要动态大小的数组，必须手动管理内存，这容易导致内存泄漏或缓冲区溢出等问题。std::vector 自动管理其大小，根据需要动态分配和释放内存，消除了手动管理内存的复杂性。

2. 内存安全性

std::vector 提供内存安全性。通过RAII（资源获取即初始化）机制，std::vector 确保在作用域结束时自动释放内存，避免了传统数组中常见的内存泄漏问题。此外，std::vector 的边界检查功能（在使用at方法时）可以防止越界访问。

3. 方便的接口

std::vector 提供了丰富的成员函数，如push_back、insert、erase等，使得元素的增删操作更加直观和简洁。相比之下，传统数组需要手动计算索引和内存偏移来进行类似操作，容易出错且代码冗长。

4. 异常安全性

在使用std::vector 时，如果发生异常（如内存分配失败），vector 会自动回滚到操作前的状态，保证数据的一致性。而传统数组在异常情况下，可能会导致内存泄漏或未定义行为。

6. 与标准库的兼容性

std::vector 是C++标准模板库（STL）的一部分，可以无缝与STL算法（如sort、find等）和其他容器（如map、set）结合使用。传统数组在与STL算法结合时，需要手动转换为指针范围或其他容器形式。

2. vector的基本概念

2.1 vector的定义

单独定义一个vector：

vector < typename > name;

上面这个定义其实相当于是一维数组name[size]，只不过其size可以根据需要进行变化，这就是“变长数组”的名字的由来。

这里的typename可以是任何基本类型，例如int、double、char、结构体等，也可以是STL标准容器，例如set、queue、vector等。

下面我们以int为例子介绍vector的几种定义方式：

v1：一个空的vector。

vector < int > v1

v2：这个vector中包含10个int，并且默认初始化为0。

vector < int > v2(10);

代码示例：

#include "iostream"
#include "vector"

using namespace std;

int main(){
    vector <int> v2(10);
  
    cout << "v2: ";
    for(int i = 0; i < v2.size(); i++){
        cout  << v2[i]<<" ";
    }

    return 0;
}

运行结果：

v2: 0 0 0 0 0 0 0 0 0 0 
进程已结束，退出代码为 0

v3：这个vector中包含10个int，并且手动初始化为1。

vector < int > v3(10,1);

代码示例：

#include "iostream"
#include "vector"

using namespace std;

int main(){
    vector <int> v3(10,1);

    cout << "v3: ";
    for(int i = 0; i < v3.size(); i++){
        cout  << v3[i]<<" ";
    }


    return 0;
}

运行结果：

v3: 1 1 1 1 1 1 1 1 1 1 
进程已结束，退出代码为 0

v4：这个vector中采用v2迭代器区间进行开空间和初始化，并且空间大小和初始化内容与v2相同,即v4包含10个int，初始化为0。

vector < int > v4(v2.begin(),v2,end())

代码示例：

#include "iostream"
#include "vector"

using namespace std;

int main(){
    vector <int> v2(10);

    vector <int> v4(v2.begin(), v2.end());

    cout << "v4: ";
    for(int i = 0; i < v4.size(); i++){
        cout  << v4[i]<<" ";
    }


    return 0;
}

运行结果：

v4: 0 0 0 0 0 0 0 0 0 0 
进程已结束，退出代码为 0

v5：这个vector中采用拷贝构造初始化，并且空间大小和初始化内容与v3相同,即v5包含10个int，初始化为1。

vector < int > v5（v3）

代码示例：

#include "iostream"
#include "vector"

using namespace std;

int main(){
    vector <int> v3(10,1);

    vector <int> v5(v3);

    cout << "v5: ";
    for(int i = 0; i < v5.size(); i++){
        cout  << v5[i]<<" ";
    }


    return 0;
}

运行结果：

v5: 1 1 1 1 1 1 1 1 1 1 

进程已结束，退出代码为 0

v6：这个vector中采用了初始化列表初始化，{}中有几个元素就代表开了几个空间，{}中内容表示初始化的值。这是c++11中的语法。

vector < int >v6{1,2,3,4};

代码示例：

#include "iostream"
#include "vector"

using namespace std;

int main(){

    vector <int> v6{1,2,3,4};

    cout << "v6: ";
    for (int num:v6){
        cout  << num <<" ";
    }
    cout << endl;
    
    return 0;
}

运行结果：

v6: 1 2 3 4 

进程已结束，退出代码为 0

2.2 vector中元素的访问

（1）使用at进行访问，at访问不到元素是抛异常。

cout << v6.at(1) << endl;

代码示例：

#include "iostream"
#include "vector"

using namespace std;

int main(){

    vector <int> v6{1,2,3,4};


    cout << "v6: ";
    for(int i = 0; i < v6.size(); i++){
        cout  << v6.at(i)<<" ";
    }
    cout << endl;

    return 0;
}

结果展示：

v6: 1 2 3 4 

进程已结束，退出代码为 0

（2）像数组一样进行访问。

cout << v6[0] << endl;

代码示例：

#include "iostream"
#include "vector"

using namespace std;

int main(){

    vector <int> v6{1,2,3,4};


    cout << "v6: ";
    for(int i = 0; i < v6.size(); i++){
        cout  << v6[i]<<" ";}
    cout << endl;

    return 0;
}

运行结果：

v6: 1 2 3 4 

进程已结束，退出代码为 0

（3）vecctor::begin() 指向第一个元素

std::vector<int>::iterator it = numbers.begin();

代码示例：

#include <iostream>
#include <vector>

int main() {
    // 创建一个存储整数的 vector
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用 vector::begin() 获取第一个元素的迭代器
    std::vector<int>::iterator it = numbers.begin();
    //std::vector<int>::iterator 是一个类型定义，用于表示 std::vector<int> 的迭代器类型。

    // 输出第一个元素
    std::cout << "The first element is: " << *it << std::endl;

    // 使用迭代器遍历整个 vector
    std::cout << "All elements in the vector: ";
    for (it = numbers.begin(); it != numbers.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

运行结果：

The first element is: 1
All elements in the vector: 1 2 3 4 5 

进程已结束，退出代码为 0

vecctor::rbegin() 反向迭代器，指向元素最后一个元素

代码示例：

#include <iostream>
#include <vector>

int main() {
    // 创建一个存储整数的 vector
    std::vector<int> numbers = {10, 20, 30, 40, 50};

    // 使用 vector::end() 获取尾后迭代器
    std::vector<int>::reverse_iterator it = numbers.rbegin();

    std::cout << "numbers.rbegin()获取的是：" << *it << std::endl;

    return 0;
}

运行结果是：

numbers.rbegin()获取的是：50

进程已结束，退出代码为 0

vecctor::rend() 反向迭代器，指向容器第一个元素的前一个位置。

作用1：获取第一个元素；

代码示例：

#include <iostream>
#include <vector>

int main() {
    // 创建一个存储整数的 vector
    std::vector<int> numbers = {10, 20, 30, 40, 50};

    // 使用 vector::end() 获取尾后迭代器
    
    std::vector<int>::reverse_iterator it2 = numbers.rend() - 1;

    std::cout << "numbers.rend()获取的是：" << *it2 << std::endl;

    return 0;
}

结果展示：

numbers.rend()获取的是：10

进程已结束，退出代码为 0

作用2：和rbegin()一起使用反向遍历 vector

代码示例：

#include <iostream>
#include <vector>

int main() {
    // 创建一个存储整数的 vector
    std::vector<int> numbers = {10, 20, 30, 40, 50};

    // 使用反向迭代器遍历整个 vector
    std::cout << "Elements in the vector in reverse order: ";
    for (std::vector<int>::reverse_iterator rit = numbers.rbegin(); rit != numbers.rend(); ++rit) {
        std::cout << *rit << " ";
    }
    std::cout << std::endl;

    return 0;
}

结果展示：

Elements in the vector in reverse order: 50 40 30 20 10 

进程已结束，退出代码为 0

2.3 vector中空间增长

在 C++ 中，std::vector 是一种动态数组，它可以在需要时自动调整其大小以容纳更多的元素。向量的这种自动增长机制涉及到空间的管理，尤其是容量的调整，这也是 std::vector 高效运作的关键之一。

空间增长机制

1. 容量与大小的区别
  • 大小（size）：当前向量中实际存储的元素数量，可以通过 vector::size() 函数获得。
  • 容量（capacity）：向量当前能够存储的最大元素数量，而无需进行重新分配，可以通过 vector::capacity() 函数获得。

当向量的大小超出其当前容量时，向量会自动增加容量以容纳更多的元素。这种容量的增加通常会比所需的元素数量大，从而减少频繁的内存分配开销。

2. 增长策略

std::vector 的增长策略一般是按倍数（如 1.5 倍或 2 倍）来增加容量。具体的增长因实现而异，但常见的增长方式是：

  • 当当前容量为 0 时，分配一个初始的容量。
  • 当向量的大小超过容量时，容量通常会增加到当前容量的 1.5 倍或 2 倍。

这种按倍数增长的策略旨在平衡内存分配的开销和向量扩展时的效率。尽管会导致一些未使用的空间，但它大大减少了重新分配和复制的频率。

3. 重新分配（Reallocation）

当向量的容量不足时，会触发重新分配。重新分配过程包括以下步骤：

  • 分配一个更大的内存块（通常是当前容量的 1.5 倍或 2 倍）。
  • 将现有元素复制到新内存块中。
  • 释放旧的内存块。

这个过程可能会导致所有现有的迭代器、引用和指针失效，因为底层存储的位置已经改变。

代码示例

以下代码演示了向量的空间增长：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;
    std::cout << "Initial capacity: " << vec.capacity() << std::endl;

    for (int i = 0; i < 10; ++i) {
        vec.push_back(i);
        std::cout << "Size: " << vec.size() << ", Capacity: " << vec.capacity() << std::endl;
    }

    return 0;
}

输出示例：

Initial capacity: 0
Size: 1, Capacity: 1
Size: 2, Capacity: 2
Size: 3, Capacity: 4
Size: 4, Capacity: 4
Size: 5, Capacity: 8
Size: 6, Capacity: 8
Size: 7, Capacity: 8
Size: 8, Capacity: 8
Size: 9, Capacity: 16
Size: 10, Capacity: 16

从输出中可以看出，当 size 达到 capacity 时，向量的容量会自动翻倍（或按其他倍数增长）。例如，从容量 4 增加到 8，再从 8 增加到 16。

手动控制容量

C++ 标准库提供了一些方法来手动控制向量的容量：

  • reserve()：预先分配足够的内存，以减少后续的重新分配。例如，vec.reserve(100) 会确保 vec 能够存储至少 100 个元素，而不进行中途的重新分配。

  • shrink_to_fit()：请求缩小向量的容量，使其与当前大小相匹配。这是一个非强制性操作，取决于实现。

性能考虑

空间增长的设计旨在权衡性能与内存使用：

  • 性能：通过倍增策略，减少了内存分配的频率，提升了 push_back() 等操作的平均性能。
  • 内存效率：由于按倍数增长，向量可能会预留一些未使用的内存。这在内存敏感的环境中需要注意。

总结

std::vector 的空间增长机制是其高效动态行为的基础。理解这个机制对于优化向量的使用、避免不必要的重新分配开销、以及在需要时手动调整容量是非常重要的。

2.4 vector中增删查改

2.4.1. 增加元素（Insert）

std::vector 提供了几种方法来向向量中添加元素：

push_back()

将元素添加到向量的末尾。这个操作会自动调整向量的大小，如果容量不足，可能会触发重新分配

#include <vector>
#include <iostream>

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

    vec.push_back(10); // 添加元素10到末尾
    vec.push_back(20);
    
    for (int i : vec) {
        std::cout << i << " "; // 输出: 10 20
    }

    return 0;
}
emplace_back()

与 push_back() 类似，但它直接在向量末尾构造元素，避免了临时对象的创建。

std::vector<std::pair<int, int>> vec;
vec.emplace_back(1, 2);  // 直接构造pair(1, 2)到向量中
insert()

在指定位置插入一个或多个元素，可能会导致重新分配和元素的移动。

std::vector<int> vec = {10, 20, 30};
vec.insert(vec.begin() + 1, 15);  // 在第二个位置插入15

// vec内容: 10, 15, 20, 30
emplace()

与 insert() 类似，但直接在指定位置构造元素，避免了临时对象的创建。

vec.emplace(vec.begin() + 1, 15); // 直接在第二个位置构造15

2.4.2. 删除元素（Erase）

pop_back()

移除向量末尾的元素，不会返回该元素。

std::vector<int> vec = {10, 20, 30};
vec.pop_back(); // 移除30

// vec内容: 10, 20
erase()

移除指定位置或范围内的元素，并调整后续元素的位置。

std::vector<int> vec = {10, 20, 30, 40};
vec.erase(vec.begin() + 1); // 移除第二个元素

// vec内容: 10, 30, 40

vec.erase(vec.begin(), vec.begin() + 2); // 移除前两个元素

// vec内容: 40
clear()

移除所有元素，将向量大小变为0，但不改变容量。

std::vector<int> vec = {10, 20, 30};
vec.clear(); // 移除所有元素

// vec内容: 空

2.4.3. 修改元素（Modify）

 通过索引修改

使用下标操作符 [] 或 at() 来访问并修改元素。

std::vector<int> vec = {10, 20, 30};
vec[1] = 25; // 修改第二个元素为25

// vec内容: 10, 25, 30

vec.at(2) = 35; // 修改第三个元素为35

// vec内容: 10, 25, 35

2.4.4. 查询元素（Access）

通过索引访问

使用下标操作符 [] 或 at() 来访问元素。at() 提供边界检查，如果索引超出范围会抛出 std::out_of_range 异常。

std::vector<int> vec = {10, 20, 30};
int value1 = vec[1]; // 获取第二个元素20
int value2 = vec.at(2); // 获取第三个元素30
front() 和 back()
  • front() 返回第一个元素的引用。
  • back() 返回最后一个元素的引用。
std::vector<int> vec = {10, 20, 30};
int first = vec.front(); // 获取第一个元素10
int last = vec.back();   // 获取最后一个元素30
data()

返回指向向量内存数组的指针，便于与 C 风格数组或其他需要指针的 API 交互。

std::vector<int> vec = {10, 20, 30};
int* p = vec.data(); // 指向第一个元素的指针

std::cout << *p << std::endl; // 输出: 10
 遍历向量

可以使用传统的 for 循环、范围 for 循环或迭代器来遍历向量的元素。

std::vector<int> vec = {10, 20, 30};

// 使用传统for循环
for (size_t i = 0; i < vec.size(); ++i) {
    std::cout << vec[i] << " ";
}

// 使用范围for循环
for (int value : vec) {
    std::cout << value << " ";
}

// 使用迭代器
for (auto it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << " ";
}

总结

  • 增：使用 push_back()、emplace_back() 追加元素；使用 insert()、emplace() 在指定位置插入元素。
  • 删：使用 pop_back() 移除最后一个元素；使用 erase() 移除指定位置的元素；使用 clear() 清空向量。
  • 改：通过索引或使用 front()、back() 直接访问并修改元素。
  • 查：使用 [] 或 at() 访问元素；使用 front() 和 back() 访问首尾元素；使用 data() 获取底层数组指针。

这些操作使 std::vector 成为一个功能强大且灵活的容器，可以应对各种应用场景。

3. vector的常用成员函数

push_back() 与 pop_back()：添加与移除元素。

  • operator[] 与 at()：访问元素。
  • begin() 与 end()：迭代器的使用。
  • size() 与 capacity()：大小与容量的区别。
  • resize() 与 reserve()：调整大小与容量管理。
  • empty() 与 clear()：清空vector。
  • insert() 与 erase()：插入与移除元素。

姜太公钓鲸233
关注
C++：标准库类型vector
weixin_44808331的博客
07-24 257
参考资料：《C++ Primer》、博客随笔 一、什么是vector 向量（vector）是一个封装了任意类型动态大小数组的顺序容器。 可变大小数组。支持快速随机访问。在尾部之外的位置插入或删除元素可能很慢。 vector表示对象的集合，其中所有对象的类型都相同。 vector是一个类模板。 使用vector，必须包含<vector>头文件，使用using声明 特别注...
[C++] std::vector
weixin_55664293的博客
05-30 5112
std::vector template < class T, class Alloc = allocator<T> > class vector; // generic template vector是表示可以改变大小的数组的序列容器。 就像数组一样，向量对其元素使用连续的存储位置，这意味着也可以使用指向其元素的常规指针上的偏移量来访问它们的元素，并且与在数组中一样有效。但与数组不同的是，它们的大小可以动态变化，它们的存储由容器自动处理。 在内部，向量使用动态分配的数组来
C++的std::vector
xiaofeixia002X的博客
02-20 503
是C++标准库中的一个，它。允许你在运行时，自动管理存储空间的分配和释放。由于其灵活性和易用性，在C++程序中被广泛使用，特别是在需要存储一系列元素时。
C++之std::vector
Luck-Dream的博客
02-28 928
resize(size_type count): 更改 vector 的大小，使其包含 count 个元素。的元数据存储在栈区，而实际的元素数组存储在堆区，并且数组的大小是根据需要动态改变的。使用场景：适用于元素结构简单，变化小，并且频繁随机访问但不需要对头部和中间元素进行添加删除操作的场景。//5个元素的数组，且初始化值为1。//在itr的位置插入两个99。//在itr的位置插入元素88。缺点：在头部和中间插入删除元素需要移动内存，效率低；//查找特定的迭代器。
C++ std::vector
休息一下接着来的博客
07-31 819
标准库类型vector表示对象集合，其中所有的对象的类型都相同。vector常常被称为容器（container）。使用vector时，需要引入对应的头文件。vector本质上是一个类模板。 #include <vector> // 包含对应的头文件 using std::vector 1. vector的定义和初始化 vector<T> v1; // v1 是一个空vector，它潜在的元素是T类型，执行默认初始化 vector<T> V2(V1); //
C++ vector的用法小结
12-31
c++ vector用法 C++内置的数组支持容器的机制，但是它不支持容器抽象的语义。要解决此问题我们自己实现这样的类。在标准C++中，用容器向量（vector）实现。容器向量也是一个类模板。 标准库vector类型使用需要的...
通过代码实例解析c++ vector常用方法
12-17
C++中的`std::vector`是一个非常常用的容器，它提供了动态数组的功能，可以在运行时方便地添加、删除和访问元素。下面将通过几个实例详细解释如何使用`std::vector`的一些常见方法。 1. **向vector中的每个元素添加...
C++ vector删除符合条件的元素示例分享
12-31
C++ vector中实际删除元素使用的是容器vecrot std::vector::erase()方法。C++ 中std::remove()并不删除元素，因为容器的size()没有变化，只是元素的替换。 1.std::vector::erase() 函数原型：iterator erase ...
c++ vector(向量)使用方法详解(顺序访问vector的多种方式）
09-04
C++中的`std::vector`是一个动态数组，它允许存储同一类型的元素集合，并提供了高效的操作接口。`vector`是标准模板库（STL）的一部分，是C++编程中常用的数据结构之一。以下是对`vector`的详细介绍，以及如何进行...
C++ vector使用的一些注意事项
08-25
C++ vector使用的一些注意事项 C++ 中的 vector 是一个非常常用的容器类，它提供了一个动态数组的实现，能够自动管理内存，避免了手动内存管理的麻烦。然而，在使用 vector 时需要注意一些问题，这篇文章将为大家...
std::vector使用简介
Tony2wang的博客
03-12 470
使用vector，需添加头文件#include， 要使用sort或find，则需要添加头文件#include&amp;lt;algorithm&amp;gt;。 为了简化书写，需在.h中增加using namespace std; 1.vector的初始化及赋值 std::vector nVec;　　　　 // 空对象 std::vector nVec(5,-1);　 // 创建了一个包含5个元素...
c++ std::vector
肥猫王德福的博客
11-17 2102
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
C++ std::vector::vector向量（构造向量、构造容器、vector容器）
Dontla的博客
05-16 781
文章目录cppman std::vector::vector上面文档中的代码示例 cppman std::vector::vector std::vector::vector(3) C++ Programmer's Manual std::vector::vector(3) NAME std::vect
C++ 中的 std::vector：动态数组操作和常用函数解析
南城小馆
11-15 5690
C++ 中的 std::vector 是一个非常实用的容器，它提供了动态大小的数组功能，可以存储任意类型的元素，并且可以方便地进行元素的添加、删除和查询操作。本博客不仅介绍了一些常用的成员函数和操作符，如 push_back()、pop_back()、size()、empty() 和 clear()，还详细对比了 push_back() 和 emplace_back() 之间的区别。此外，博客还提供了一些小示例程序，以帮助读者更好地理解这些概念。
C++ —— std vector
老友不要辣的博客
10-26 1052
std::vector变量名(容器个数, 初始化的值);
C++笔记：std::vector
南城同学的博客
02-18 339
声明格式 std::verctor<数据类型> 变量名 std::verctor<int> studentId; std::verctor<int> studentId{1, 2, 3}; std::verctor<int>studentId(5); //注意是（），而不是{}，设置这个verctor拥有5个元素 std::verctor<int>studentId(5, 100); //设置这个verctor拥有5个元素，每个元素的初始值是
C++容器之向量(std::vector)
最新发布
flysnow010的博客
05-27 1251
矢量(vector)是序列容器，表示可以更改大小的数组。就像数组一样，向量为其元素使用连续的存储位置，这意味着也可以使用指向其元素的常规指针上的偏移量来访问其元素，并且与数组中一样高效。但与数组(array)不同的是，它们的大小可以动态变化，其存储由容器自动处理。在内部，向量使用动态分配的数组来存储其元素。当插入新元素时，可能需要重新分配此数组以增加其大小，这意味着分配一个新数组并将所有元素移动到该数组。就处理时间而言，这是一项相对昂贵的任务，因此，每次向容器中添加元素时，矢量不是每次都重新分配。
C++ std::vector 容器
qq_29796781的博客
05-07 348
&lt;1&gt;有文件  #include &lt;vector&gt;&lt;2&gt;创建vector对象std::vector&lt;int&gt; vec; //模板类型可以是 int double short string struct class map list set vector等&lt;3&gt;数据插入vectorvec.push_back(a); vec.push_ba...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值