要获取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
的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
的容量管理策略：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的大小和容量管理不当，很容易踩到一些坑，或者导致不必要的性能开销。
-
频繁的内存重新分配：这是最主要的性能陷阱。每次
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++代码的重要实践。
