C++如何使用std::array和std::vector高效管理数组

根据数组大小是否在编译时确定来选择std::array或std::vector：若大小固定且已知，使用std::array以获得零运行时开销和更好缓存性能；若大小需在运行时动态调整，则选用std::vector，并通过reserve()等策略优化性能，避免频繁内存重新分配。

C++中高效管理数组，核心在于根据数据特性和使用场景，明智地选择

std::array

std::vector

std::array

std::vector

解决方案

在使用C++管理数组时，

std::array

std::vector

std::array

std::array

begin()

end()

size()

empty()

立即学习“C++免费学习笔记（深入）”；

• 优点：
  • 零运行时开销： 没有堆分配和释放的成本。
  • 类型安全： 提供了边界检查（通过

    at()

    登录后复制
    方法），避免了C风格数组越界的风险。
  • 迭代器支持： 可以方便地与STL算法配合使用。
  • 值语义： 拷贝

    std::array

    登录后复制
    会复制所有元素，行为清晰。
• 缺点：
  • 大小固定： 一旦定义，大小就不能改变。
  • 编译时已知大小： 无法处理运行时才能确定大小的场景。

示例：

#include <array>
#include <iostream>
#include <numeric> // For std::iota

void processFixedData() {
    std::array<int, 5> scores; // 声明一个包含5个整数的array
    // 初始化
    for (size_t i = 0; i < scores.size(); ++i) {
        scores[i] = (i + 1) * 10;
    }
    // 使用at()进行安全访问
    try {
        std::cout << "Score at index 2: " << scores.at(2) << std::endl;
        // scores.at(10) = 100; // 这会抛出std::out_of_range异常
    } catch (const std::out_of_range& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    // 遍历
    for (int score : scores) {
        std::cout << score << " ";
    }
    std::cout << std::endl;
}

std::vector

std::vector

std::vector

• 优点：
  • 动态大小： 运行时可以任意增删元素，无需预先知道大小。
  • 自动内存管理： RAII（资源获取即初始化）原则，无需手动

    new

    登录后复制
    /

    delete

    登录后复制
    。
  • 高效增长： 通常以指数级增长策略来减少重新分配的次数。
  • 迭代器支持： 同样可以方便地与STL算法配合使用。
• 缺点：
  • 堆分配开销： 涉及堆内存的分配和释放，可能比栈分配慢。
  • 重新分配开销： 当容量不足时，需要重新分配更大的内存块并复制元素，这可能是一个昂贵的操作。
  • 迭代器失效： 重新分配会导致所有指向

    vector

    登录后复制
    内部元素的迭代器、指针和引用失效。

示例：

#include <vector>
#include <iostream>
#include <algorithm> // For std::sort

void processDynamicData() {
    std::vector<double> temperatures; // 声明一个空的double类型vector
    // 添加元素
    temperatures.push_back(25.5);
    temperatures.push_back(28.1);
    temperatures.push_back(22.0);
    std::cout << "Current temperatures: ";
    for (double temp : temperatures) {
        std::cout << temp << " ";
    }
    std::cout << std::endl;

    // 动态调整大小
    temperatures.push_back(30.2); // 可能会触发重新分配
    std::cout << "After adding one more, size: " << temperatures.size() << ", capacity: " << temperatures.capacity() << std::endl;

    // 排序
    std::sort(temperatures.begin(), temperatures.end());
    std::cout << "Sorted temperatures: ";
    for (double temp : temperatures) {
        std::cout << temp << " ";
    }
    std::cout << std::endl;
}

选择策略：

• 编译时已知固定大小 → 选用

  std::array

  登录后复制
  。比如，一个表示RGB颜色的3个

  unsigned char

  登录后复制
  ，或者一个棋盘的固定尺寸。
• 运行时动态大小，或大小不确定 → 选用

  std::vector

  登录后复制
  。比如，从文件中读取未知数量的数据，或者用户输入的列表。

何时选择std::array而非std::vector？

在我看来，选择

std::array

std::vector

std::array

首先，

std::array

std::array

std::vector

std::array

其次，

std::array

std::array<float, 3>

std::array<unsigned char, 4>

std::array

再者，

std::array

std::array<T, N>

当然，我们不能忽视其类型安全的特性。虽然C风格数组也可以是固定大小，但

std::array

at()

[]

at()

总而言之，当你面对以下情况时，不妨优先考虑

std::array

• 数组的元素数量在编译时完全确定，且不会在运行时改变。
• 你需要极致的性能，尤其是在内存分配和缓存利用方面。
• 数组通常较小，适合在栈上分配。
• 你希望通过类型系统明确表达数组大小固定的意图。

std::vector的动态性与性能优化策略

std::vector

std::vector

std::vector

std::vector

push_back

1. 分配一块更大的内存区域（通常是当前容量的1.5倍或2倍）。
2. 将所有现有元素从旧内存区域复制（或移动）到新内存区域。
3. 释放旧内存区域。 这个过程是昂贵的，尤其是当元素数量庞大或元素类型具有复杂的拷贝/移动语义时。

为了缓解这个问题，最有效的策略就是使用

std::vector::reserve()

reserve()

示例：使用

reserve()

如此AI写作

AI驱动的内容营销平台，提供一站式的AI智能写作、管理和分发数字化工具。

137

查看详情

#include <vector>
#include <iostream>
#include <chrono>

void demoVectorReserve() {
    std::vector<int> data;
    const int num_elements = 1000000;

    // 不使用 reserve()
    auto start_no_reserve = std::chrono::high_resolution_clock::now();
    std::vector<int> vec_no_reserve;
    for (int i = 0; i < num_elements; ++i) {
        vec_no_reserve.push_back(i);
    }
    auto end_no_reserve = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff_no_reserve = end_no_reserve - start_no_reserve;
    std::cout << "Without reserve(): " << diff_no_reserve.count() << " s" << std::endl;
    std::cout << "Capacity without reserve: " << vec_no_reserve.capacity() << std::endl;

    // 使用 reserve()
    auto start_with_reserve = std::chrono::high_resolution_clock::now();
    std::vector<int> vec_with_reserve;
    vec_with_reserve.reserve(num_elements); // 预留足够的空间
    for (int i = 0; i < num_elements; ++i) {
        vec_with_reserve.push_back(i);
    }
    auto end_with_reserve = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff_with_reserve = end_with_reserve - start_with_reserve;
    std::cout << "With reserve():    " << diff_with_reserve.count() << " s" << std::endl;
    std::cout << "Capacity with reserve: " << vec_with_reserve.capacity() << std::endl;
}

通过上面的例子，你会发现使用

reserve()

除了

reserve()

• shrink_to_fit()

  登录后复制
  ： 当你确定

  std::vector

  登录后复制
  不再需要额外的容量时，

  shrink_to_fit()

  登录后复制
  可以请求

  vector

  登录后复制
  释放未使用的内存，将其容量调整为与当前大小相同。这对于内存敏感的应用非常有用，但要注意，它可能涉及重新分配和元素移动，所以只在

  vector

  登录后复制
  大小稳定后使用。
• 移动语义（C++11及更高版本）： 对于非基本数据类型，使用

  emplace_back()

  登录后复制
  而非

  push_back()

  登录后复制
  通常更高效，因为它可以在

  vector

  登录后复制
  内部直接构造对象，避免了额外的拷贝操作。如果

  push_back()

  登录后复制
  接收的是右值引用，它也会利用移动语义，但

  emplace_back()

  登录后复制
  在某些情况下可以提供更细粒度的控制。
• 批量插入： 如果你有一组数据需要添加到

  std::vector

  登录后复制
  ，使用

  insert()

  登录后复制
  方法的迭代器版本通常比循环调用

  push_back()

  登录后复制
  更高效，因为它可以在一次操作中处理所有元素的插入，可能只触发一次重新分配。
• 避免不必要的拷贝： 当向

  std::vector

  登录后复制
  中添加自定义对象时，确保你的对象支持移动语义（即有移动构造函数和移动赋值运算符），这样在重新分配时可以避免昂贵的深拷贝。

理解并应用这些策略，能让

std::vector

std::array和std::vector的内存管理与迭代器失效

深入理解

std::array

std::vector

std::array

std::array

std::array

std::array

std::array

这意味着对于

std::array

• 内存是连续且不可变的。
• 迭代器、指针和引用永远不会失效（除非

  std::array

  登录后复制
  对象本身被销毁）。你可以放心地存储指向

  std::array

  登录后复制
  元素的指针或迭代器，它们将始终有效，直到

  std::array

  登录后复制
  的生命周期结束。

这种稳定性是

std::array

std::vector

std::vector

std::vector

1. 分配一块新的、更大的内存区域。
2. 将旧内存区域中的所有元素移动（或复制）到新内存区域。
3. 释放旧内存区域。

这个过程直接导致了

std::vector

以下是导致

std::vector

• push_back()

  登录后复制
  /

  emplace_back()

  登录后复制
  ： 当

  vector

  登录后复制
  的

  capacity()

  登录后复制
  不足以容纳新元素时，会发生重新分配，导致所有迭代器失效。

• insert()

  登录后复制
  ： 在

  vector

  登录后复制
  的任何位置插入元素都可能导致重新分配（如果容量不足），从而使所有迭代器失效。即使不发生重新分配，

  insert()

  登录后复制
  操作也会使插入点及其之后的所有迭代器失效，因为它们所指向的元素可能已经向后移动了。

• erase()

  登录后复制
  ： 删除

  vector

  登录后复制
  中的元素会导致被删除元素之后的所有元素向前移动。因此，

  erase()

  登录后复制
  操作会使被删除元素以及其之后的所有迭代器失效。

• clear()

  登录后复制
  ： 清空

  vector

  登录后复制
  会使所有迭代器失效。

• resize()

  登录后复制
  ： 如果

  resize()

  登录后复制
  操作导致

  vector

  登录后复制
  容量增加，则可能发生重新分配，所有迭代器失效。如果容量减少，则被移除元素之后的迭代器失效。

• assign()

  登录后复制
  ： 重新赋值

  vector

  登录后复制
  内容会使所有迭代器失效。

如何处理迭代器失效：

理解迭代器失效的规则至关重要。在实际编程中，我们通常需要采取以下策略来避免问题：

• 重新获取迭代器： 在可能导致迭代器失效的操作之后，立即重新获取所需的迭代器。

  std::vector<int> myVec = {1, 2, 3, 4, 5};
  auto it = myVec.begin() + 2; // 指向3
  
  myVec.push_back(6); // 可能导致重新分配，it失效
  
  // 错误的使用方式：std::cout << *it << std::endl;
  
  // 正确的做法：重新获取迭代器
  it = myVec.begin() + 2;
  std::cout << *it << std::endl; // 仍然指向3

  登录后复制

• 结构化循环： 在循环中进行

  erase()

  登录后复制
  或

  insert()

  登录后复制
  操作时，需要特别小心。
  • 删除元素时，通常从后向前遍历，这样

    erase()

    登录后复制
    操作就不会影响尚未遍历到的元素。

    for (auto it = myVec.rbegin(); it != myVec.rend(); ++it) {
    if (*it % 2 != 0) { // 删除奇数
        myVec.erase(std::next(it).base()); // 注意rbegin/rend与erase的配合
    }
    }

    登录后复制
  • 或者，在

    erase()

    登录后复制
    后更新迭代器：

    it = myVec.erase(it);

    登录后复制

    for (auto it = myVec.begin(); it != myVec.end(); ) {
    if (*it % 2 != 0) {
        it = myVec.erase(it); // erase返回指向下一个元素的迭代器
    } else {
        ++it;
    }
    }

    登录后复制

• 使用索引而非迭代器： 如果你只是需要访问元素，并且不进行

  insert

  登录后复制
  /

  erase

  登录后复制
  操作，使用整数索引

  []

  登录后复制
  通常更安全，因为它不受迭代器失效的影响（但仍然需要注意数组越界）。

掌握这些内存管理和迭代器失效的细微之处，能让你在C++中使用

std::array

std::vector

以上就是C++如何使用std::array和std::vector高效管理数组的详细内容，更多请关注php中文网其它相关文章！