【C/C++ Vector容量调整】理解C++ Vector：Reserve与Resize的区别与应用

泡沫o0

已于 2024-10-31 16:13:05 修改

阅读量6.4k

点赞数 13

分类专栏： C/C++ 编程世界: 探索C/C++的奥妙 C/C++ 工程师日常篇文章标签： c语言 c++ 嵌入式 arm 开发语言 arm开发 linux

于 2023-07-02 23:24:56 首次发布

本文链接：https://blog.csdn.net/qq_21438461/article/details/131506807

版权

C/C++ 编程世界: 探索C/C++的奥妙同时被 3 个专栏收录

648 篇文章

订阅专栏

C/C++ 工程师日常篇

17 篇文章

订阅专栏

C++ 中的封装和抽象技术

16 篇文章

订阅专栏

理解C++ Vector：Reserve与Resize的区别与应用

1. 引言

在C++编程中，我们经常会使用到一种名为Vector的动态数组。Vector是一种非常强大的工具，它可以帮助我们处理各种复杂的数据结构。然而，对于Vector的两个重要操作——Reserve和Resize，很多开发者可能并不完全理解它们的含义和使用场景。本文将深入探讨这两个操作，帮助读者更好地理解和使用它们。

1.1 C++ Vector简介

C++ Vector（向量）是一个动态数组，它可以在运行时动态地增加或减少元素。Vector是STL（Standard Template Library，标准模板库）中的一部分，它提供了许多强大的功能，如自动管理内存、提供各种内置函数等。

1.2 Reserve与Resize的基本定义

在C++中，std::vector 的 reserve 和 resize 是两个常用的操作，用于调整 vector 的容量和大小，但它们的功能和使用场景有所不同。

Reserve：
- 功能：预分配 vector 的容量。
- 作用：当预期向 vector 中添加大量元素时，使用 reserve 可以预先分配足够的内存，避免多次重新分配，从而提高性能。
- 注意：reserve 只改变 capacity，不会影响 size，即不会改变当前元素的数量或状态。
Resize：
- 功能：改变 vector 的大小。
- 作用：
  - 增大大小：如果新大小超过当前容量，resize 会分配更多内存以容纳新元素。
  - 减小大小：销毁多余的元素，但不会减少已分配的内存。
- 注意：resize 仅改变 size，不会自动释放多余的内存。若需要减少 capacity 以释放内存，可以结合使用 shrink_to_fit。

2.1 Reserve操作的深入理解

Reserve操作是用于预分配Vector的容量。当我们知道将要在Vector中存储大量的元素时，可以使用Reserve来预先分配足够的内存。这样可以避免在添加元素时频繁地重新分配内存，从而提高程序的性能。

std::vector<int> vec;
vec.reserve(100); // 预分配100个元素的内存

需要注意的是，Reserve操作只是预分配内存，并不会改变Vector的大小。也就是说，即使我们调用了Reserve，Vector的size()函数仍然会返回0，因为实际上并没有添加任何元素到Vector中。

2.2 Resize操作的深入理解

Resize 操作用于改变 std::vector 的大小。当需要增加或减少 vector 中的元素数量时，可以使用 resize 操作。具体行为如下：

增加大小：
- 如果新大小超过当前容量，resize 会分配更多内存以容纳新元素。
- 新增的元素会被默认初始化（对于基本类型如 int，初始化为 0）。
减少大小：
- 销毁多余的元素，但不会减少已分配的内存容量 (capacity)。

#include <vector>

int main() {
    std::vector<int> vec;
    vec.resize(100); // 改变 Vector 的大小为 100
    // vec 现在包含 100 个元素，值均为 0
    return 0;
}

在上述例子中，调用 resize 将 vector 的大小调整为 100。这意味着 vector 现在包含 100 个元素，所有新添加的元素都被初始化为 0。调用 vec.size() 将返回 100，表示 vector 中有 100 个元素。

2.3 Reserve和Resize的比较

虽然 reserve 和 resize 都用于调整 std::vector 的内存，但它们的功能和使用场景有所不同：

Reserve：
- 功能：预分配 vector 的容量。
- 作用：当预期向 vector 中添加大量元素时，使用 reserve 可以预先分配足够的内存，避免多次重新分配，从而提高性能。
- 注意：reserve 只改变 capacity，不会影响 size，即不会改变当前元素的数量或状态。
Resize：
- 功能：改变 vector 的大小。
- 作用：
  - 增大大小：如果新大小超过当前容量，resize 会分配更多内存以容纳新元素。
  - 减小大小：销毁多余的元素，但不会减少已分配的内存容量。
- 注意：resize 仅改变 size，不会自动释放多余的内存。若需要减少 capacity 以释放内存，可以结合使用 shrink_to_fit。

选择使用场景：

使用 reserve：
- 当确定将要添加大量元素，并希望优化性能，减少内存重新分配次数时。
使用 resize：
- 当需要明确控制 vector 中元素的数量时，例如初始化特定大小的容器或调整元素数量。

3. 常见错误与解决方法

3.1 错误：访问超出Vector的实际大小

这是一个非常常见的错误，通常发生在我们试图访问Vector中不存在的元素时。例如，如果我们创建了一个大小为5的Vector，然后试图访问第10个元素，就会出现这个错误。

std::vector<int> vec(5);
int x = vec[10]; // 错误：访问超出Vector的实际大小

要解决这个问题，我们需要确保我们访问的元素索引在Vector的实际大小范围内。

3.2 错误：在Reserve后通过下标访问元素

这是一个比较微妙的错误，可能会在我们使用Reserve预分配内存后出现。如前所述，Reserve只是预分配内存，并不会改变Vector的大小。因此，如果我们在Reserve后试图通过下标访问预分配的内存，就会出现错误。

std::vector<int> vec;
vec.reserve(100); // 预分配100个元素的内存
int x = vec[50]; // 错误：在Reserve后通过下标访问元素

要解决这个问题，我们需要在Reserve后使用push_back或insert等函数来实际添加元素，或者直接使用Resize来改变Vector的大小。

3.3 错误：在没有足够内存的情况下进行Reserve或Resize

这是一个比较严重的错误，可能会导致程序崩溃。如果我们试图在没有足够内存的情况下进行Reserve或Resize，就会出现这个错误。

要解决这个问题，我们需要确保我们有足够的内存来进行Reserve或Resize。如果内存不足，我们可能需要考虑使用其他的数据结构，或者优化我们的程序来减少内存使用。

4. 底层原理

当然，以下是调整后的 4. 底层原理 部分，确保避免与 2.2 和 2.3 的内容冗余，同时保持准确性：

4. 底层原理

4.1 Vector的内存管理

std::vector 是一种动态数组，其元素在内存中以连续的方式存储。这种布局提供了高效的随机访问能力和良好的缓存局部性。然而，为了支持动态增长，vector 采用了一种动态内存管理策略：

容量与大小：
- 大小 (size)：当前存储的元素数量。
- 容量 (capacity)：已分配的内存空间能够容纳的最大元素数量。
动态扩展：
- 当向 vector 添加元素时，如果 size 达到 capacity，vector 会自动分配一块更大的内存区域，通常是当前容量的两倍，以减少重新分配的频率。
- 新分配的内存区域会通过移动或复制现有元素来填充，之后释放旧的内存区域。
内存分配策略：
- vector 使用动态内存分配器（如 allocator）来管理内存，这允许定制内存分配策略以优化性能或满足特定需求。
性能考量：
- 由于内存的连续性，vector 在元素访问和遍历时具有出色的性能。
- 频繁的内存重新分配和元素移动可能会影响性能，尤其是在大量元素操作时。因此，合理管理 capacity 对性能优化至关重要。

4.2 Reserve和Resize的工作原理

reserve 和 resize 是 std::vector 中用于管理内存和调整元素数量的关键操作，它们在底层通过不同的机制影响 vector 的内存分配和元素管理。

Reserve的工作原理：
- 预分配内存：调用 reserve(n) 会确保 vector 的 capacity 至少为 n。如果当前 capacity 已经足够，操作不会进行任何更改。
- 内存分配：如果需要增加容量，vector 会分配一块新的内存区域，通常是现有容量的倍数增长，以减少未来的重新分配次数。
- 元素迁移：新内存分配后，现有元素会被移动或复制到新的内存区域，旧内存随后被释放。
- 影响：reserve 仅影响 capacity，不会改变 size，因此不会初始化新元素或销毁现有元素。
Resize的工作原理：
- 改变大小：调用 resize(n) 会调整 vector 的 size 至 n。
  - 增大大小：
    - 如果 n 大于当前 size，vector 会在末尾添加默认初始化的元素（对于基本类型，如 int，初始化为 0）。
    - 如果 n 超过当前 capacity，则会触发内存重新分配，按照 reserve 的机制分配足够的内存。
  - 减小大小：
    - 如果 n 小于当前 size，vector 会销毁多余的元素，但不会立即减少 capacity。已分配的内存仍然保留，以供将来使用。
- 内存管理：
  - 增大 size 时，可能涉及内存分配和元素初始化。
  - 减小 size 时，仅涉及元素的销毁，不涉及内存的释放。要减少 capacity，需调用 shrink_to_fit。
- 影响：resize 改变 size，可能影响 capacity，并涉及元素的构造或析构，但不会自动释放内存。

4.3 错误的原因

在我们讨论的错误中，大多数都是由于我们错误地使用了Vector的内存管理功能。

当我们试图访问超出Vector大小的元素时，我们实际上是在试图访问没有分配的内存，这会导致未定义的行为。

当我们在Reserve后通过下标访问元素时，我们实际上是在试图访问预分配的内存，但是这些内存并没有被实际添加到Vector中，因此我们不能通过下标来访问它们。

当我们在没有足够内存的情况下进行Reserve或Resize时，我们实际上是在试图分配超出我们可用内存的内存，这会导致内存分配失败，进而可能导致程序崩溃。

5. 实践中的应用和高级技巧

5.1 在大型项目中有效地使用 `std::vector`

在大型项目中，std::vector 是一种高效且灵活的容器，但为了充分发挥其优势，需要注意以下几点：

数据访问模式：
- 顺序访问：vector 对于顺序访问具有极高的性能，适合需要频繁遍历的场景。
- 随机访问：虽然 vector 支持快速的随机访问，但在需要频繁插入或删除中间元素时，性能不如 std::deque 或 std::list。
内存管理：
- 预分配内存：在已知需要存储大量元素时，使用 reserve 预先分配内存，减少动态扩展带来的开销。
- 避免不必要的复制：通过移动语义和 emplace_back 来减少元素的复制和构造开销。
生命周期管理：
- 元素生命周期：确保 vector 的生命周期覆盖所有对其元素的引用，避免悬挂引用导致的未定义行为。
线程安全：
- 并发访问：std::vector 本身不是线程安全的，需通过外部同步机制（如互斥锁）来管理多线程环境下的访问。

5.2 优化 `std::vector` 的性能

优化 std::vector 性能的方法包括：

预分配内存：
```
std::vector<int> vec;
vec.reserve(1000); // 预分配足够的内存
```
通过 reserve 减少动态内存分配次数，提升插入性能。

使用 emplace_back 代替 push_back：

struct MyStruct {
    int a;
    MyStruct(int x) : a(x) {}
};

std::vector<MyStruct> vec;
vec.emplace_back(10); // 直接在容器内构造元素，避免额外的复制

emplace_back 直接在容器内构造元素，减少临时对象的创建和复制。

避免不必要的数据复制：

传递引用：
```
void processVector(const std::vector<int>& vec);
```
通过传递 const 引用，避免复制整个 vector。

使用移动语义：

std::vector<int> createVector() {
    std::vector<int> vec = {1, 2, 3};
    return vec; // 使用移动语义避免复制
}

减少内存碎片：
- 选择合适的 allocator：在特定场景下，自定义分配器可以优化内存使用。
缓存优化：
- 数据局部性：由于 vector 的元素在内存中是连续存储的，优化访问模式以提高缓存命中率。

5.3 避免 `std::vector` 的常见陷阱和错误

在使用 std::vector 时，需注意以下常见问题：

访问越界：

std::vector<int> vec = {1, 2, 3};
// 错误：访问第四个元素
// int value = vec[3]; // 未定义行为

解决方法：使用 at() 方法进行边界检查，或者确保索引在有效范围内。

if (index < vec.size()) {
    int value = vec.at(index);
}

忘记预分配内存：
在需要频繁添加大量元素时，未调用 reserve 可能导致多次重新分配，影响性能。
解决方法：在添加大量元素前调用 reserve。
```
vec.reserve(1000);
```
错误使用 resize 和 reserve：
- resize 改变 size，可能添加或移除元素。
- reserve 仅调整 capacity，不改变 size。
解决方法：根据需求正确选择操作，避免混淆两者的用途。
迭代器失效：
向 vector 添加或删除元素可能导致迭代器失效。
解决方法：在修改 vector 后重新获取迭代器，或者使用索引访问。
不必要的复制：
频繁复制 vector 会带来性能开销。
解决方法：使用引用或指针传递 vector，利用移动语义优化性能。

5.4 `std::vector` 的高级使用技巧

利用高级技巧可以进一步提升 std::vector 的效率和灵活性：

模板和泛型编程：
使用模板编写通用代码，适用于不同类型的 vector。

template <typename T>
void printVector(const std::vector<T>& vec) {
    for (const auto& elem : vec) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
}

自定义分配器：
通过自定义 allocator 优化内存分配策略，以适应特定需求或提升性能。

template <typename T>
struct MyAllocator : public std::allocator<T> {
    // 自定义分配和释放内存的方法
};

std::vector<int, MyAllocator<int>> vec;

使用 std::vector 的高级成员函数：
- shrink_to_fit：在减少 size 后释放多余内存。
```
vec.resize(newSize);
vec.shrink_to_fit();
```
- swap：高效交换两个 vector 的内容。
```
std::vector<int> vec1, vec2;
vec1.swap(vec2);
```
利用 std::vector 的内建算法：
结合标准算法（如 std::sort, std::find 等）提升代码简洁性和性能。
```
std::sort(vec.begin(), vec.end());
```
内存对齐和分区：
在高性能计算中，合理的内存对齐和分区可以显著提升缓存命中率和并行处理能力。
移动语义和完美转发：
通过利用 C++11 的移动语义，优化 vector 的性能，特别是在处理临时对象时。
```
std::vector<std::string> vec;
std::string str = "Hello";
vec.emplace_back(std::move(str)); // 避免字符串的复制
```

通过掌握和应用这些高级技巧，可以显著提升 std::vector 在复杂项目中的表现和效率。

结语

在本章的结尾，我们总结了vector的使用，包括如何在大型项目中有效地使用vector，如何优化vector的性能，如何避免vector的常见陷阱和错误，以及vector的高级使用技巧。希望这些内容能帮助你更好地理解和使用vector。

在我们的编程学习之旅中，理解是我们迈向更高层次的重要一步。然而，掌握新技能、新理念，始终需要时间和坚持。从心理学的角度看，学习往往伴随着不断的试错和调整，这就像是我们的大脑在逐渐优化其解决问题的“算法”。

这就是为什么当我们遇到错误，我们应该将其视为学习和进步的机会，而不仅仅是困扰。通过理解和解决这些问题，我们不仅可以修复当前的代码，更可以提升我们的编程能力，防止在未来的项目中犯相同的错误。

我鼓励大家积极参与进来，不断提升自己的编程技术。无论你是初学者还是有经验的开发者，我希望我的博客能对你的学习之路有所帮助。如果你觉得这篇文章有用，不妨点击收藏，或者留下你的评论分享你的见解和经验，也欢迎你对我博客的内容提出建议和问题。每一次的点赞、评论、分享和关注都是对我的最大支持，也是对我持续分享和创作的动力。