理解C++ STL容器中capacity与size的区别对性能优化至关重要，因为size表示当前元素数量，capacity表示已分配内存能容纳的最大元素数。当size超过capacity时，容器会触发重新分配，导致昂贵的内存拷贝操作，尤其在vector和string等连续内存容器中影响显著。通过reserve()预先分配内存可避免频繁重分配，shrink_to_fit()可释放多余容量，而swap技巧能彻底清空内存。capacity概念主要适用于vector和string这类连续存储容器，list、map等非连续存储容器则无此概念。合理使用这些策略可有效提升程序性能并减少资源浪费。
在我看来，C++ STL容器中的
capacity
和
size
，是理解容器底层运作机制，进而写出高效代码的关键所在。简单来说，
size
指的是容器当前实际存储的元素数量，而
capacity
则是容器当前已分配的内存空间所能容纳的最大元素数量。这两者之间的差异，往往决定了你的程序是流畅运行，还是在不经意间遭遇性能瓶颈。
解决方案
当我们谈论C++ STL容器的
capacity
和
size
时，最典型的例子莫过于
std::vector
和
std::string
。
size
很好理解，就是你放了多少个东西进去，比如一个
std::vector v; v.push_back(1); v.push_back(2);
，这时
v.size()
就是2。但
capacity
就有些微妙了。它反映的是容器为了未来可能的扩展，预先分配了多少内存。
想象一下，你在一个房间里放东西。
size
是你已经放了多少件家具，而
capacity
则是这个房间总共能放多少件家具。当你放的家具数量（
size
）超过了房间的容量（
capacity
）时，你就需要换一个更大的房间，把所有家具搬过去，这个过程就是所谓的“重新分配”（reallocation）。
std::vector
在内部通常会维护一个指向动态数组的指针、当前元素数量（
size
）以及当前已分配内存能容纳的最大元素数量（
capacity
）。当你不断地
push_back
元素，
size
会线性增长。一旦
size
达到
capacity
，
vector
就需要重新分配一块更大的内存。这个新的内存块通常是旧内存块的1.5倍或2倍大小（具体策略取决于编译器和标准库实现）。接着，所有旧内存中的元素会被复制或移动到新内存中，然后旧内存被释放。这个重新分配的过程是相当耗时的，因为它涉及内存的申请、数据的拷贝以及旧内存的释放。
立即学习“C++免费学习笔记（深入）”；
所以，
size <= capacity
总是成立的。
capacity
的存在，是为了减少频繁的内存重新分配开销。如果每次只分配刚好能容纳当前元素的内存，那么每次
push_back
都可能导致重新分配，这在性能上是灾难性的。通过预留一些空间，
vector
可以在多次
push_back
操作中避免重新分配，从而提高效率。
C++ STL容器中，为什么理解容量和大小的区别对性能优化至关重要？
在我看来，理解
capacity
和
size
的区别，简直就是掌握
std::vector
等动态数组类容器性能命脉的第一步。我们编写程序时，很少有人能精确预知一个容器最终会存储多少数据。当数据量动态增长时，如果对
capacity
的增长策略一无所知，就很容易踩到性能的“坑”。
核心问题在于“重新分配”。每次
vector
需要扩大容量时，它不仅仅是简单地在现有内存旁边“加长”一点。通常情况下，系统需要找到一块全新的、足够大的连续内存区域，然后把所有现有元素从旧位置拷贝（或者移动）到新位置，最后才能释放旧内存。这个过程，尤其是当容器存储的是复杂对象时，涉及构造、析构、拷贝（或移动）操作，开销是巨大的。如果这个操作频繁发生，程序的整体性能就会受到严重拖累，尤其是在处理大量数据或实时性要求高的场景下。
举个例子，假设你有一个
vector
，
MyObject
的拷贝构造函数很重。如果你不预先
reserve
空间，每次
capacity
不足时，所有的
MyObject
实例都要被拷贝一次。这就像你每次家里来客人，都要把所有家具搬到更大的房子里，然后再搬回来，想想都觉得累。
通过合理地使用
reserve()
函数，我们可以提前告诉
vector
我们预计会存储多少元素，让它一次性分配足够的内存。这样，在后续的
push_back
操作中，只要
size
不超过
capacity
，就不会发生重新分配，从而大大减少了不必要的性能开销。
#include #include int main() { std::vector numbers; std::cout << "初始状态: size = " << numbers.size() << ", capacity = " << numbers.capacity() << std::endl; numbers.push_back(1); std::cout << "添加1个元素后: size = " << numbers.size() << ", capacity = " << numbers.capacity() << std::endl; numbers.push_back(2); std::cout << "添加2个元素后: size = " << numbers.size() << ", capacity = " << numbers.capacity() << std::endl; // 假设此时capacity变为2，size也为2 numbers.push_back(3); // 此时很可能发生重新分配 std::cout << "添加3个元素后: size = " << numbers.size() << ", capacity = " << numbers.capacity() << std::endl; std::vector optimized_numbers; optimized_numbers.reserve(100); // 预留100个元素的空间 std::cout << "预留100空间后: size = " << optimized_numbers.size() << ", capacity = " << optimized_numbers.capacity() << std::endl; for (int i = 0; i < 50; ++i) { optimized_numbers.push_back(i); // 这50次push_back不会发生重新分配 } std::cout << "添加50个元素后: size = " << optimized_numbers.size() << ", capacity = " << optimized_numbers.capacity() << std::endl; return 0;}
这段代码清晰地展示了
reserve()
如何帮助我们避免多次重新分配，从而优化性能。
在哪些STL容器中，容量（capacity）的概念是核心，又有哪些容器没有这一概念？
capacity
这个概念，并非所有STL容器都具有，或者说，并非所有容器都以
std::vector
那样的方式管理
capacity
。在我看来，理解这一点，能够帮助我们更好地选择合适的容器。
capacity
概念是核心的容器：
std::vector
: 这是最典型的例子，也是我们前面讨论的重点。它使用连续内存来存储元素，因此
capacity
直接对应于已分配的连续内存块能容纳的元素数量。它的增长策略和重新分配行为，直接受
capacity
管理。
std::string
:
std::string
在很多方面都可以看作是
char
的
std::vector
。它也使用连续内存来存储字符，同样有
size()
和
capacity()
成员函数，并且在字符串增长时也会发生类似的重新分配行为。
没有
capacity
概念（或以不同方式管理）的容器：
std::list
:
std::list
是一个双向链表。它的元素不是存储在连续内存中，而是分散在内存各处，通过指针连接。每个元素都是独立分配的，所以它没有一个整体的“容量”概念。你不能预留一块连续的内存给
list
，因为它根本不使用连续内存。它的
size()
就是当前元素的数量，但没有
capacity()
。
std::map
,
std::set
,
std::multimap
,
std::multiset
(关联容器): 这些容器通常基于红黑树实现。每个节点（即每个键值对或键）都是独立分配的。它们也没有一个
capacity
的概念，因为它们的内存管理是分散的、节点级的。插入一个元素，就分配一个节点；删除一个元素，就释放一个节点。
std::unordered_map
,
std::unordered_set
(无序关联容器): 这些容器基于哈希表实现。它们通常会维护一个桶（bucket）数组，每个桶可能是一个链表。虽然桶数组本身是连续的，并且可能需要重新哈希（rehash）来扩大桶数组的容量，但这与
vector
的
capacity
概念不同。
rehash
会改变桶的数量和元素在桶中的分布，但它不直接暴露一个
capacity()
函数来表示可以容纳多少个元素而不触发
rehash
。它们有
bucket_count()
来表示桶的数量，但这和
vector
的
capacity
不是一回事。
std::deque
(双端队列):
std::deque
是一个比较特殊的容器。它也提供随机访问，但它不保证所有元素都存储在连续内存中。它通常通过一系列固定大小的块（或者说页）来存储数据，这些块本身是连续的，但块之间不一定连续。当
deque
需要增长时，它会分配新的块。所以，它也没有一个单一的
capacity()
成员函数，因为它没有一个统一的、连续的内存块来衡量容量。它的内存管理策略比
vector
更复杂，但同样是为了在两端高效插入和删除。
所以，当我们思考
capacity
时，应该首先想到那些依赖连续内存存储的容器，比如
vector
和
string
。对于链表或树形结构的容器，这个概念并不适用。
如何有效地管理STL容器的容量，以避免常见的性能陷阱？
有效地管理STL容器的容量，特别是对于
std::vector
和
std::string
这类容器，是编写高性能C++代码的关键一步。这不仅仅是关于避免重新分配，更是关于内存使用效率和程序响应速度的全面考量。
预先分配（
reserve()
）：这是最直接也最有效的策略。如果你能大致预估容器需要存储的元素数量，就应该在容器开始填充数据之前调用
reserve()
。
std::vector data;data.reserve(10000); // 预计会存储10000个元素for (int i = 0; i < 10000; ++i) { data.push_back(i); // 避免了至少大部分的重新分配}
这样做的好处是显而易见的：减少了大量的内存分配、数据拷贝和释放操作，从而显著提升性能。特别是在循环中频繁添加元素时，
reserve()
的价值就体现出来了。
收缩容量（
shrink_to_fit()
）：有时，容器在某个阶段会增长到非常大，但随后又清除了大部分元素，或者只保留了少量元素。这时，
capacity
可能远大于
size
，造成内存浪费。
shrink_to_fit()
函数就是用来解决这个问题的。它会尝试将容器的
capacity
调整到与
size
相等（或尽可能接近），从而释放未使用的内存。
std::vector large_data;large_data.reserve(100000); // 预分配大量空间for (int i = 0; i < 10000; ++i) { large_data.push_back(i);}// ... 某些操作后，只剩下少量数据large_data.erase(large_data.begin() + 100, large_data.end()); // 删除了大部分元素std::cout << "删除后: size = " << large_data.size() << ", capacity = " << large_data.capacity() << std::endl;large_data.shrink_to_fit(); // 尝试释放多余内存std::cout << "shrink_to_fit后: size = " << large_data.size() << ", capacity = " << large_data.capacity() << std::endl;
需要注意的是，
shrink_to_fit()
只是一个“请求”，标准库不保证一定会收缩内存。在某些情况下，为了性能或实现上的考虑，它可能不会执行任何操作。但通常情况下，它会起作用。
清空容器的内存（
swap()
技巧）：如果你想彻底清空一个容器并释放其所有内存，包括
capacity
占用的内存，直接调用
clear()
只会将
size
置为0，而
capacity
通常不变。一个常用的技巧是与一个空的临时容器进行
swap
：
std::vector my_vector = {1, 2, 3, 4, 5};// ... 填充大量数据，让capacity很大std::cout << "清空前: size = " << my_vector.size() << ", capacity = " << my_vector.capacity() << std::endl;std::vector().swap(my_vector); // 交换后，my_vector变为空，且capacity也为0std::cout << "清空后: size = " << my_vector.size() << ", capacity = " << my_vector.capacity() << std::endl;
这个技巧利用了
swap
的效率（通常是常数时间复杂度），以及临时对象在作用域结束时自动销毁的特性。
避免不必要的拷贝：在C++11及更高版本中，利用右值引用和移动语义（
std::move
），以及
emplace_back()
而不是
push_back()
，可以进一步优化性能。
emplace_back()
允许直接在容器内部构造元素，避免了临时对象的创建和拷贝。
struct MyObject { int id; // 假设MyObject的拷贝构造函数很耗时 MyObject(int i) : id(i) { std::cout << "构造 MyObject(" << id << ")" << std::endl; } MyObject(const MyObject& other) : id(other.id) { std::cout << "拷贝构造 MyObject(" << id << ")" << std::endl; } MyObject(MyObject&& other) noexcept : id(other.id) { std::cout << "移动构造 MyObject(" << id << ")" << std::endl; }};std::vector objects;objects.reserve(2); // 预留空间std::cout << "使用push_back(MyObject(1)):" << std::endl;objects.push_back(MyObject(1)); // 触发移动构造std::cout << "使用emplace_back(2):" << std::endl;objects.emplace_back(2); // 直接在容器内部构造
emplace_back
在某些情况下可以避免一次移动构造或拷贝构造，进一步减少开销。
管理
capacity
并非一劳永逸，它需要你对程序的内存使用模式有一个大致的理解。过度预分配可能导致内存浪费，而分配不足则会导致频繁的重新分配。找到一个平衡点，往往需要一些经验和对程序行为的洞察。
以上就是C++STL容器容量capacity与大小size区别的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1475422.html
微信扫一扫 
支付宝扫一扫 
