如何在C++中获取vector的大小_C++ vector大小与容量管理

尼克

发布时间：2025-09-22 08:55:01

1084人浏览过

来源于php中文网

原创

要获取std::vector的大小，应调用其.size()成员函数，它返回当前元素数量，时间复杂度为O(1)；size()表示实际元素个数，capacity()表示已分配内存可容纳的元素总数，size() ≤ capacity()；通过reserve(n)可预先分配内存避免频繁扩容提升性能，shrink_to_fit()则尝试释放多余容量；需注意扩容会导致迭代器、指针失效，且resize()改变元素数量而reserve()仅改变容量。

如何在c++中获取vector的大小_c++ vector大小与容量管理

在C++中，要获取

std::vector

的大小，最直接、最常用的方法就是调用它的成员函数

.size()

。这个函数会返回

vector

当前实际包含的元素数量，也就是它当前有多“满”。

解决方案

要获取

std::vector

的大小，我们只需要简单地调用其

.size()

成员函数即可。这个函数不接受任何参数，并返回一个无符号整型值，通常是

std::vector::size_type

，它等同于

std::size_t

。这个返回值精确地告诉我们

vector

中当前有多少个元素。

举个例子：

#include 
#include 
#include 

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

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

可以一次性分配足够的内存，使得在后续的

次

push_back

操作中，

vector

无需再进行内存重新分配和元素拷贝。这对于性能敏感的代码来说，是个非常有效的优化手段。

超会AI

AI驱动的爆款内容制造机

下载

#include 
#include 
#include  // 用于测量时间

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

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

int main() {
    std::vector 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().swap(myVector);
```
  这会创建一个临时的空
```
vector
```
  ，然后与
```
myVector
```
  交换，
```
myVector
```
  就变成了空的且容量为0，而旧的
```
myVector
```
  （现在是临时的空
```
vector
```
  ）在语句结束时被销毁，从而释放了内存。