C++ STL容器resize与reserve用法详解

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

C++ STL容器中的resize和reserve方法，简单来说，一个关乎容器内元素的数量，另一个则专注于容器底层内存的容量预留。resize会改变容器的实际大小，可能涉及元素的构造或销毁；而reserve仅仅是预分配内存，不改变元素数量，也不触及元素的生命周期，它更多是为了优化性能，避免频繁的内存重新分配。

解决方案

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

std::vector::reserve(size_type new_cap)

reserve的职责是确保容器的内部容量（capacity()）至少能容纳new_cap个元素。它做的仅仅是内存预分配。

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

示例：

std::vector 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 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都需要：

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

这些操作，特别是复制/移动元素，开销非常大。对于10000个元素，你可能会经历十几次甚至更多的重新分配。每一次都意味着大量的数据移动。而一旦你调用了vec.reserve(10000)，vector会一次性分配好足够的内存。后续的10000次push_back操作，只要不超过这个容量，就不会触发任何内存重新分配，元素可以直接在预留好的空间中构造。这带来的性能提升，在实际项目中是非常显著的。

我通常会这样思考：如果你有一个函数，它的任务是收集数据并返回一个vector，而且你大概知道数据量的上限，那么在函数开始时就reserve一下，能让整个过程跑得更顺畅。当然，前提是你对数据量有个合理的预估，否则过度reserve也可能导致内存浪费。

错误使用resize或reserve可能导致哪些内存问题和陷阱？

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

reserve的陷阱：

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

resize的陷阱：

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

总的来说，关键在于理解size和capacity这两个概念的根本区别，以及它们如何影响内存和元素的生命周期。

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

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

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

最常见的组合模式是：先reserve预留内存，然后通过push_back（或emplace_back）填充元素，最后如果需要，再用resize调整最终的元素数量。

1. 预知最大容量，逐步填充： 如果你知道容器可能达到的最大元素数量（或一个合理的上限），但实际填充的元素数量可能不确定，或者需要通过循环逐个添加，那么先reserve是最佳选择。

   std::vector 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()则准确反映了实际添加的元素数量。

2. 需要精确数量的占位符，并可能后续修改： 如果你需要一个容器，一开始就包含特定数量的元素（作为占位符），并且这些元素可能在后续被修改，那么直接使用resize。

   std::vector scores;
   scores.resize(5, 0); // 创建一个包含5个0的vector，作为初始分数
   
   // 后续可以修改这些分数
   scores[0] = 95;
   scores[4] = 88;

   这种情况下，resize直接设定了容器的逻辑大小和初始内容。

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

   std::vector data_points;
   data_points.reserve(200); // 预计最多有200个数据点
   
   // 收集数据，通过 push_back 添加
   for (int i = 0; i < 150; ++i) { // 假设实际只收集了150个
       data_points.push_back(static_cast(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()。

理解这两种操作的内在机制和应用场景，是写出高效、健出C++代码的基础。