C++STL容器容量capacity与大小size区别-C++-PHP中文网

理解C++ STL容器中capacity与size的区别对性能优化至关重要，因为size表示当前元素数量，capacity表示已分配内存能容纳的最大元素数。当size超过capacity时，容器会触发重新分配，导致昂贵的内存拷贝操作，尤其在vector和string等连续内存容器中影响显著。通过reserve()预先分配内存可避免频繁重分配，shrink_to_fit()可释放多余容量，而swap技巧能彻底清空内存。capacity概念主要适用于vector和string这类连续存储容器，list、map等非连续存储容器则无此概念。合理使用这些策略可有效提升程序性能并减少资源浪费。

c++stl容器容量capacity与大小size区别

在我看来，C++ STL容器中的

capacity

登录后复制

和

size

登录后复制

，是理解容器底层运作机制，进而写出高效代码的关键所在。简单来说，

size

登录后复制

指的是容器当前实际存储的元素数量，而

capacity

登录后复制

则是容器当前已分配的内存空间所能容纳的最大元素数量。这两者之间的差异，往往决定了你的程序是流畅运行，还是在不经意间遭遇性能瓶颈。

解决方案

当我们谈论C++ STL容器的

capacity

登录后复制

和

size

登录后复制

时，最典型的例子莫过于

std::vector

登录后复制

和

std::string

登录后复制

。

size

登录后复制

很好理解，就是你放了多少个东西进去，比如一个

std::vector<int> 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>

登录后复制

，

MyObject

登录后复制

的拷贝构造函数很重。如果你不预先

reserve

登录后复制

空间，每次

capacity

登录后复制

不足时，所有的

MyObject

登录后复制

实例都要被拷贝一次。这就像你每次家里来客人，都要把所有家具搬到更大的房子里，然后再搬回来，想想都觉得累。

通过合理地使用

reserve()

登录后复制

函数，我们可以提前告诉

vector

登录后复制

我们预计会存储多少元素，让它一次性分配足够的内存。这样，在后续的

push_back

登录后复制

操作中，只要

size

登录后复制

不超过

capacity

登录后复制

，就不会发生重新分配，从而大大减少了不必要的性能开销。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> 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<int> 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()

登录后复制

如何帮助我们避免多次重新分配，从而优化性能。

AGI-Eval评测社区

AI大模型评测社区

查看详情

在哪些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<int> 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<int> 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<int> my_vector = {1, 2, 3, 4, 5};
// ... 填充大量数据，让capacity很大
std::cout << "清空前: size = " << my_vector.size() << ", capacity = " << my_vector.capacity() << std::endl;

std::vector<int>().swap(my_vector); // 交换后，my_vector变为空，且capacity也为0
std::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<MyObject> 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); // 直接在容器内部构造

登录后复制