C++STL容器resize和reserve使用方法-C++-PHP中文网

resize改变容器中元素的数量，涉及构造或销毁；reserve仅预分配内存，不改变元素数量，用于优化性能避免频繁重分配。

c++stl容器resize和reserve使用方法

C++ STL容器中的

resize

登录后复制

和

reserve

登录后复制

方法，简单来说，一个关乎容器内元素的数量，另一个则专注于容器底层内存的容量预留。

resize

登录后复制

会改变容器的实际大小，可能涉及元素的构造或销毁；而

reserve

登录后复制

仅仅是预分配内存，不改变元素数量，也不触及元素的生命周期，它更多是为了优化性能，避免频繁的内存重新分配。

解决方案

理解

resize

登录后复制

和

reserve

登录后复制

的核心差异，是高效使用C++ STL容器的关键。它们虽然都与容器的“大小”有关，但操作的层面完全不同。

std::vector::reserve(size_type new_cap)

登录后复制

reserve

登录后复制

的职责是确保容器的内部容量（

capacity()

登录后复制

）至少能容纳

new_cap

登录后复制

个元素。它做的仅仅是内存预分配。

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

行为： 如果
```
new_cap
```
登录后复制
大于当前的
```
capacity()
```
登录后复制
，容器会重新分配一块更大的内存，并将现有元素复制或移动到新位置，然后释放旧内存。如果
```
new_cap
```
登录后复制
小于或等于当前的
```
capacity()
```
登录后复制
，
```
reserve
```
登录后复制
通常不做任何事情（标准允许实现自由，但通常不会收缩容量）。
对
size()
登录后复制
和
capacity()
登录后复制
的影响：调用
```
reserve
```
登录后复制
后，
```
size()
```
登录后复制
不会改变，但
```
capacity()
```
登录后复制
可能会增加。
元素： 不涉及元素的构造、销毁或赋值。容器中的元素数量和它们的值都保持不变。
目的： 主要用于性能优化。当你知道容器最终会包含大量元素时，提前调用
```
reserve
```
登录后复制
可以避免在后续添加元素（如
```
push_back
```
登录后复制
）时频繁地进行内存重新分配，因为内存重新分配是一个开销相对较大的操作。每次重新分配，所有现有元素都需要被移动，这在处理大数据时可能导致显著的性能瓶颈。

示例：

std::vector<int> vec;
std::cout << "初始: size=" << vec.size() << ", capacity=" << vec.capacity() << std::endl;
// 输出: 初始: size=0, capacity=0 (或某个小值)

vec.reserve(10);
std::cout << "reserve(10)后: size=" << vec.size() << ", capacity=" << vec.capacity() << std::endl;
// 输出: reserve(10)后: size=0, capacity=10 (或更大)

for (int i = 0; i < 5; ++i) {
    vec.push_back(i);
}
std::cout << "push_back 5个元素后: size=" << vec.size() << ", capacity=" << vec.capacity() << std::endl;
// 输出: push_back 5个元素后: size=5, capacity=10

登录后复制

std::vector::resize(size_type count)

登录后复制

和
std::vector::resize(size_type count, const T& value)
登录后复制

resize

登录后复制

的职责是改变容器中实际元素的数量（

size()

登录后复制

）。

行为：
- 如果
```
count
```
  登录后复制
  大于当前的
```
size()
```
  登录后复制
  ：容器会添加新的元素，直到
```
size()
```
  登录后复制
  达到
```
count
```
  登录后复制
  。新添加的元素会进行值初始化（如果提供了
```
value
```
  登录后复制
  ，则用
```
value
```
  登录后复制
  拷贝构造；否则进行默认构造）。这个过程可能伴随着内存重新分配，如果当前的
```
capacity()
```
  登录后复制
  不足以容纳
```
count
```
  登录后复制
  个元素。
- 如果
```
count
```
  登录后复制
  小于当前的
```
size()
```
  登录后复制
  ：容器会从末尾删除元素，直到
```
size()
```
  登录后复制
  达到
```
count
```
  登录后复制
  。被删除的元素会被销毁。
对
size()
登录后复制
和
capacity()
登录后复制
的影响：
```
size()
```
登录后复制
会变为
```
count
```
登录后复制
。
```
capacity()
```
登录后复制
可能会增加（如果需要容纳更多元素），但通常不会减少（除非调用
```
shrink_to_fit()
```
登录后复制
）。
元素： 涉及元素的构造、销毁或赋值。
目的： 用于改变容器中实际存储的元素数量。当你需要一个容器精确地拥有特定数量的元素，并且希望这些新元素被初始化时，
```
resize
```
登录后复制
是你的选择。

示例：

std::vector<int> vec;
vec.resize(5); // 容器现在有5个元素，都是默认初始化的0
std::cout << "resize(5)后: size=" << vec.size() << ", capacity=" << vec.capacity() << std::endl;
// 输出: resize(5)后: size=5, capacity=5 (或更大)
for (int x : vec) {
    std::cout << x << " "; // 输出: 0 0 0 0 0
}
std::cout << std::endl;

vec.resize(3); // 容器现在有3个元素，最后两个被销毁
std::cout << "resize(3)后: size=" << vec.size() << ", capacity=" << vec.capacity() << std::endl;
// 输出: resize(3)后: size=3, capacity=5 (或更大)
for (int x : vec) {
    std::cout << x << " "; // 输出: 0 0 0
}
std::cout << std::endl;

vec.resize(7, 99); // 容器现在有7个元素，新增的4个是99
std::cout << "resize(7, 99)后: size=" << vec.size() << ", capacity=" << vec.capacity() << std::endl;
// 输出: resize(7, 99)后: size=7, capacity=7 (或更大)
for (int x : vec) {
    std::cout << x << " "; // 输出: 0 0 0 99 99 99 99
}
std::cout << std::endl;

登录后复制

何时应优先使用

reserve

登录后复制

来优化容器的性能？

我个人经验里，

reserve

登录后复制

常常被低估，尤其是在处理大量数据，并且数据是逐步添加到容器中时。如果你预见到一个

std::vector

登录后复制

最终会容纳数百、数千甚至更多元素，并且你主要通过

push_back

登录后复制

或

emplace_back

登录后复制

来填充它，那么提前调用

reserve

登录后复制

几乎总是一个明智的选择。

想象一下，你有一个循环，需要向

std::vector

登录后复制

中添加10000个元素。如果没有

reserve

登录后复制

，

vector

登录后复制

的

capacity

登录后复制

会以指数增长的方式进行重新分配（例如，从0到1，再到2，再到4，8，16...）。每次重新分配，

vector

登录后复制

都需要：

分配一块更大的新内存。
将所有现有元素从旧内存复制或移动到新内存。
销毁旧内存中的元素。
释放旧内存。

这些操作，特别是复制/移动元素，开销非常大。对于10000个元素，你可能会经历十几次甚至更多的重新分配。每一次都意味着大量的数据移动。而一旦你调用了

vec.reserve(10000)

登录后复制

，

vector

登录后复制

会一次性分配好足够的内存。后续的10000次

push_back

登录后复制

操作，只要不超过这个容量，就不会触发任何内存重新分配，元素可以直接在预留好的空间中构造。这带来的性能提升，在实际项目中是非常显著的。

我通常会这样思考：如果你有一个函数，它的任务是收集数据并返回一个

vector

登录后复制

，而且你大概知道数据量的上限，那么在函数开始时就

reserve

登录后复制

一下，能让整个过程跑得更顺畅。当然，前提是你对数据量有个合理的预估，否则过度

reserve

登录后复制

也可能导致内存浪费。

AI图像编辑器

使用文本提示编辑、变换和增强照片

查看详情

错误使用

resize

登录后复制

或

reserve

登录后复制

可能导致哪些内存问题和陷阱？

使用这两个函数，如果理解不深，确实会踩到一些坑。

reserve

登录后复制

的陷阱：

过度预留内存： 如果你
```
reserve
```
登录后复制
了远超实际所需的容量，比如
```
reserve(1000000)
```
登录后复制
，但最终只
```
push_back
```
登录后复制
了100个元素，那么你就会浪费大量的内存。这部分内存虽然没有被元素实际占用，但它被
```
vector
```
登录后复制
“持有”了，其他地方就不能使用。在内存受限的环境下，这可能导致不必要的内存压力。虽然可以通过
```
shrink_to_fit()
```
登录后复制
尝试回收多余容量，但这本身也是一个开销。
不改变
size()
登录后复制
的误解：有些新手可能会误以为
```
reserve(N)
```
登录后复制
之后，就可以直接通过
```
vec[i]
```
登录后复制
来访问
```
i < N
```
登录后复制
的元素。这是错误的！
```
reserve
```
登录后复制
只改变
```
capacity()
```
登录后复制
，
```
size()
```
登录后复制
仍然是0。尝试访问
```
vec[0]
```
登录后复制
会导致未定义行为，因为容器中根本没有元素。正确的做法是在
```
reserve
```
登录后复制
后使用
```
push_back
```
登录后复制
或
```
emplace_back
```
登录后复制
来添加元素。

resize

登录后复制

的陷阱：

不必要的构造/销毁开销： 如果
```
resize
```
登录后复制
的目标大小大于当前大小，新添加的元素会被默认构造（或拷贝构造）。如果你的元素类型是自定义的复杂对象，其构造函数可能涉及资源分配（如文件句柄、网络连接、其他内存分配等），那么
```
resize
```
登录后复制
操作可能会产生巨大的性能开销。我见过不少新手在用
```
resize
```
登录后复制
时，没考虑到自定义类型默认构造的开销，尤其是在循环中频繁
```
resize
```
登录后复制
，那性能下降得真是肉眼可见。
默认值问题：
```
resize(count)
```
登录后复制
会用默认值初始化新元素。对于
```
int
```
登录后复制
、
```
double
```
登录后复制
等基本类型，默认值通常是0。但对于自定义类型，你需要确保其默认构造函数是可用的，并且其行为符合你的预期。如果你期望一个特定的初始值，务必使用
```
resize(count, value)
```
登录后复制
。
意外的截断： 如果你
```
resize
```
登录后复制
到一个小于当前
```
size()
```
登录后复制
的值，那么超出部分的元素会被销毁。如果这些元素持有重要的资源，或者它们的销毁会触发副作用，你必须确保这是你想要的行为。例如，一个
```
vector
```
登录后复制
存储了指向动态分配内存的智能指针，
```
resize
```
登录后复制
可能会意外地释放这些资源。

总的来说，关键在于理解

size

登录后复制

和

capacity

登录后复制

这两个概念的根本区别，以及它们如何影响内存和元素的生命周期。

resize

登录后复制

和

reserve

登录后复制

可以一起使用吗？它们的最佳实践是什么？

是的，

resize

登录后复制

和

reserve

登录后复制

不仅可以一起使用，在某些场景下，它们组合起来能提供更精细的控制和更优的性能。这两种方法各自解决不同的问题，结合使用时，能兼顾内存预分配的效率和元素数量的精确控制。

组合使用的场景和最佳实践：

最常见的组合模式是：先

reserve

登录后复制

预留内存，然后通过
push_back
登录后复制
（或
emplace_back
登录后复制
）填充元素，最后如果需要，再用
resize
登录后复制
调整最终的元素数量。

预知最大容量，逐步填充： 如果你知道容器可能达到的最大元素数量（或一个合理的上限），但实际填充的元素数量可能不确定，或者需要通过循环逐个添加，那么先
```
reserve
```
登录后复制
是最佳选择。
```
std::vector<MyObject> objects;
objects.reserve(1000); // 预留1000个MyObject的内存空间

// 假设通过某个循环或算法添加元素
for (int i = 0; i < some_dynamic_count; ++i) {
    if (condition_met) {
        objects.push_back(MyObject(i)); // 高效添加，避免重新分配
    }
}
// 此时 objects.size() 可能小于等于 1000
```
登录后复制
这种模式下，
```
reserve
```
登录后复制
保证了
```
push_back
```
登录后复制
的高效性，而
```
size()
```
登录后复制
则准确反映了实际添加的元素数量。
需要精确数量的占位符，并可能后续修改： 如果你需要一个容器，一开始就包含特定数量的元素（作为占位符），并且这些元素可能在后续被修改，那么直接使用
```
resize
```
登录后复制
。
```
std::vector<int> scores;
scores.resize(5, 0); // 创建一个包含5个0的vector，作为初始分数

// 后续可以修改这些分数
scores[0] = 95;
scores[4] = 88;
```
登录后复制
这种情况下，
```
resize
```
登录后复制
直接设定了容器的逻辑大小和初始内容。

预留容量并填充，然后截断或扩展： 这是一种更复杂的组合，它结合了前两者的优点。

std::vector<double> data_points;
data_points.reserve(200); // 预计最多有200个数据点

// 收集数据，通过 push_back 添加
for (int i = 0; i < 150; ++i) { // 假设实际只收集了150个
    data_points.push_back(static_cast<double>(i) * 1.5);
}

// 此时 data_points.size() 是 150，capacity 至少是 200。
// 如果现在需要确保容器正好有 180 个元素，多余的用 0.0 填充
data_points.resize(180, 0.0);
// 现在 data_points.size() 是 180，capacity 至少是 200。
// 如果需要减少到 100 个元素
data_points.resize(100); // 后面的80个元素被销毁

登录后复制

我通常是这样用：如果我能大致估算出最终的元素数量，我会先

reserve

登录后复制

一下。然后，如果我需要填充一个特定数量的占位符，或者要截断容器，我才会动用

resize

登录后复制

。这是一种很务实的做法，兼顾了性能和逻辑清晰度。

总结最佳实践：

reserve
登录后复制
：当你主要通过
```
push_back
```
登录后复制
或
```
emplace_back
```
登录后复制
向容器添加元素，并且能大致预估最终元素数量时，使用
```
reserve
```
登录后复制
来避免频繁的内存重新分配，优化性能。
resize
登录后复制
：当你需要容器精确地包含特定数量的元素，并且希望这些元素被默认构造或拷贝构造为特定值时，使用
```
resize
```
登录后复制
。它直接改变容器的逻辑大小。
不要混淆：永远记住
```
reserve
```
登录后复制
只影响
```
capacity()
```
登录后复制
，不影响
```
size()
```
登录后复制
；
```
resize
```
登录后复制
则改变
```
size()
```
登录后复制
，并可能影响
```
capacity()
```
登录后复制
。