要获取std::vector的大小，应调用其.size()成员函数，它返回当前元素数量，时间复杂度为O(1)；size()表示实际元素个数，capacity()表示已分配内存可容纳的元素总数，size() ≤ capacity()；通过reserve(n)可预先分配内存避免频繁扩容提升性能，shrink_to_fit()则尝试释放多余容量；需注意扩容会导致迭代器、指针失效，且resize()改变元素数量而reserve()仅改变容量。
在C++中，要获取
std::vector
的大小，最直接、最常用的方法就是调用它的成员函数
.size()
。这个函数会返回
vector
当前实际包含的元素数量，也就是它当前有多“满”。
解决方案
要获取
std::vector
的大小，我们只需要简单地调用其
.size()
成员函数即可。这个函数不接受任何参数，并返回一个无符号整型值，通常是
std::vector::size_type
，它等同于
std::size_t
。这个返回值精确地告诉我们
vector
中当前有多少个元素。
举个例子：
#include <iostream> #include <vector> #include <string> int main() { std::vector<int> numbers = {10, 20, 30, 40, 50}; // 获取vector中元素的数量 size_t currentSize = numbers.size(); std::cout << "vector 'numbers' 的当前大小是: " << currentSize << std::endl; // 输出 5 numbers.push_back(60); // 添加一个元素 std::cout << "添加元素后，vector 'numbers' 的大小是: " << numbers.size() << std::endl; // 输出 6 std::vector<std::string> words; std::cout << "空vector 'words' 的大小是: " << words.size() << std::endl; // 输出 0 if (words.empty()) { // 也可以用empty()来判断是否为空 std::cout << "'words' vector 是空的。" << std::endl; } return 0; }
.size()
是一个非常基础且高频使用的函数，它的时间复杂度是常数级别的（O(1)），所以你可以放心地在任何需要知道
vector
当前元素数量的地方使用它，不用担心性能问题。
立即学习“C++免费学习笔记（深入）”；
std::vector
std::vector
的
size()
与
capacity()
有什么区别？
这是个很常见的问题，也常常让人感到困惑。在我看来，理解
size()
和
capacity()
是掌握
std::vector
性能特性的关键。
size()
，就像我们前面提到的，代表的是
vector
当前实际存储的元素数量。你可以把它想象成你家里的餐桌上实际摆放了多少个盘子。
而
capacity()
（容量），则表示
vector
当前已经分配了多少内存空间，可以容纳多少个元素，而无需重新分配内存。这就像你餐桌的大小，它能摆放的最大盘子数量。
所以，一个核心的关系是：
size() <= capacity()
。
vector
为了提高效率，尤其是当你在末尾频繁添加元素（比如
push_back
）时，它不会每次都只分配刚刚好的内存。当
size()
达到
capacity()
时，
vector
就需要进行一次“扩容”操作。这个扩容通常会分配一块更大的新内存，然后将旧内存中的所有元素拷贝到新内存中，最后释放旧内存。这个过程是比较耗时的。
举个例子，你有一个
vector
，初始容量可能是10。当你
push_back
第11个元素时，
vector
会发现当前容量不够了，它可能会分配一个容量为20的新内存块，把之前的10个元素复制过去，再把第11个元素放进去。这样，在接下来的9次
push_back
操作中，就不需要再扩容了。这种策略就是为了实现
push_back
的摊销常数时间复杂度。
#include <iostream> #include <vector> int main() { std::vector<int> data; std::cout << "初始状态: size = " << data.size() << ", capacity = " << data.capacity() << std::endl; for (int i = 0; i < 10; ++i) { data.push_back(i); // 观察size和capacity的变化 std::cout << "添加 " << i << ": size = " << data.size() << ", capacity = " << data.capacity() << std::endl; } // 假设在我的系统上，vector的扩容策略是翻倍 // 当size达到capacity时，capacity会翻倍 // 比如：0, 1, 2, 4, 8, 16... // 每次capacity变化都意味着一次内存重新分配和元素拷贝 return 0; }
通过观察上面的输出，你会发现
capacity
并不是每次
push_back
都会增加，它只会在
size
等于
capacity
时才增加，而且通常会以倍数增长。
vector
vector
的容量管理策略：
reserve()
与
shrink_to_fit()
既然我们知道了
capacity
的存在以及扩容的开销，那么自然就会想到如何主动管理它，避免不必要的性能损耗。这里就引入了
reserve()
和
shrink_to_fit()
。
reserve(n)
：这个函数是用来预留空间的。当你明确知道
vector
最终大概会包含多少个元素时，或者在一个循环中会频繁
push_back
大量元素时，提前调用
reserve(n)
可以一次性分配足够的内存，使得在后续的
n
次
push_back
操作中，
vector
无需再进行内存重新分配和元素拷贝。这对于性能敏感的代码来说，是个非常有效的优化手段。
#include <iostream> #include <vector> #include <chrono> // 用于测量时间 int main() { std::vector<int> numbers; const int num_elements = 1000000; // 不使用reserve() auto start_no_reserve = std::chrono::high_resolution_clock::now(); for (int i = 0; i < num_elements; ++i) { numbers.push_back(i); } auto end_no_reserve = std::chrono::high_resolution_clock::now(); std::chrono::duration<double> diff_no_reserve = end_no_reserve - start_no_reserve; std::cout << "不使用reserve()，添加 " << num_elements << " 个元素耗时: " << diff_no_reserve.count() << " 秒" << std::endl; numbers.clear(); // 清空，准备下一次测试 // 使用reserve() auto start_reserve = std::chrono::high_resolution_clock::now(); numbers.reserve(num_elements); // 提前预留空间 for (int i = 0; i < num_elements; ++i) { numbers.push_back(i); } auto end_reserve = std::chrono::high_resolution_clock::now(); std::chrono::duration<double> diff_reserve = end_reserve - start_reserve; std::cout << "使用reserve()，添加 " << num_elements << " 个元素耗时: " << diff_reserve.count() << " 秒" << std::endl; // 你会发现使用reserve()通常会快很多 return 0; }
通过上面的测试，你会直观地感受到
reserve()
带来的性能提升。
shrink_to_fit()
：与
reserve()
相反，
shrink_to_fit()
是用来尝试减少
vector
的容量，使其容量尽可能地与当前
size()
匹配。当你
vector
中删除了大量元素，或者
vector
在某个阶段达到了一个很大的容量，但现在实际使用的元素很少时，多余的内存就成了浪费。调用
shrink_to_fit()
可以请求
vector
释放这些多余的内存。
需要注意的是，
shrink_to_fit()
只是一个“请求”，标准并没有强制要求
vector
必须收缩其容量。具体是否收缩以及收缩到什么程度，取决于具体的标准库实现。但在大多数现代C++标准库中，它通常会尝试将容量调整到
size()
的大小。
#include <iostream> #include <vector> int main() { std::vector<int> data; data.reserve(100); // 预留100个空间 for (int i = 0; i < 5; ++i) { data.push_back(i); } std::cout << "填充少量元素后: size = " << data.size() << ", capacity = " << data.capacity() << std::endl; // size=5, capacity=100 data.shrink_to_fit(); // 尝试收缩容量 std::cout << "调用shrink_to_fit()后: size = " << data.size() << ", capacity = " << data.capacity() << std::endl; // size=5, capacity可能变为5 return 0; }
shrink_to_fit()
在内存敏感的应用中很有用，但它本身也可能涉及内存重新分配和拷贝，所以不应频繁调用，而是在
vector
生命周期中，当其大小稳定下来且多余容量显著时考虑使用。
vector
vector
大小调整的常见陷阱与性能考量
对
vector
的大小和容量管理不当，很容易踩到一些坑，或者导致不必要的性能开销。
-
频繁的内存重新分配：这是最主要的性能陷阱。每次
capacity
不足以容纳新元素而发生扩容时，都会涉及：
- 分配一块新的更大内存。
- 将所有现有元素从旧内存复制到新内存。
- 释放旧内存。 这个过程在元素数量庞大时会非常耗时。这就是为什么
reserve()
如此重要。
-
迭代器、指针和引用的失效：当
vector
发生扩容（即
capacity
改变）时，由于底层内存块可能被移动到新的位置，所有指向
vector
内部元素的迭代器、指针和引用都会失效。这意味着它们不再指向有效的内存地址，继续使用它们会导致未定义行为（通常是程序崩溃）。
#include <iostream> #include <vector> int main() { std::vector<int> nums = {1, 2, 3}; int* p_first = &nums[0]; // 指向第一个元素的指针 std::cout << "原始第一个元素: " << *p_first << std::endl; // 1 // 此时nums的capacity可能很小，比如3或4 // 连续push_back可能导致扩容 nums.push_back(4); nums.push_back(5); // 假设这次push_back导致了扩容 // 此时p_first可能已经失效了，因为它指向的内存可能已经被释放 // 尝试访问它可能导致段错误或其他未定义行为 // std::cout << "扩容后第一个元素 (可能失效): " << *p_first << std::endl; // 危险操作！ // 正确的做法是重新获取指针或迭代器 p_first = &nums[0]; std::cout << "扩容后重新获取的第一个元素: " << *p_first << std::endl; // 1 return 0; }这个陷阱非常隐蔽，尤其是在大型项目中，一个看似无害的
push_back
可能在某个特定条件下触发扩容，导致之前保存的迭代器或指针失效，从而引发难以追踪的bug。
-
resize()
与
reserve()
的混淆：
-
resize(n)
：改变
vector
的
size()
。如果
n
大于当前
size()
，
vector
会添加新元素，并用默认构造函数（或指定值）初始化它们；如果
n
小于当前
size()
，
vector
会删除多余的元素。
resize()
也可能导致扩容。
-
reserve(n)
：只改变
vector
的
capacity()
，不改变
size()
，也不会添加或删除元素。它只是预留了内存。 理解两者的区别至关重要。如果你只是想预留空间以提高后续插入的效率，使用
reserve()
；如果你想改变
vector
的实际元素数量并可能初始化它们，使用
resize()
。
-
-
clear()
与
erase()
：
-
clear()
：将
vector
的
size()
设置为0，但通常不会改变
capacity()
。这意味着它清空了所有元素，但保留了已分配的内存，下次再添加元素时可以复用。
-
erase()
：删除指定范围的元素，
size()
会相应减少，
capacity()
通常不会改变。 如果你需要彻底释放
vector
占用的所有内存（包括容量），一个常见的技巧是：
std::vector<T>().swap(myVector);
这会创建一个临时的空
vector
，然后与
myVector
交换，
myVector
就变成了空的且容量为0，而旧的
myVector
（现在是临时的空
vector
）在语句结束时被销毁，从而释放了内存。
-
总之，高效地使用
std::vector
不仅仅是知道如何获取其大小，更重要的是理解其背后的内存管理机制。合理地使用
reserve()
来避免不必要的扩容，注意迭代器失效的问题，并根据实际需求选择
resize()
、
clear()
或
shrink_to_fit()
，这些都是编写健壮、高性能C++代码的重要实践。