C++ vector自动扩容时机

vector的底层内存模型就是一个数组，但vector的容量却是可以动态增长的。

当插入新的元素内存不够时，会自动扩容，不同的编译器扩容的倍数也不一样，Linux下通常为原容量的两倍。扩容之后将原来的元素拷贝到新的内存空间上，然后把原来的内存空间释放掉。

size 和 capacity

• size代表当前容器内元素的个数。
• capacity表示容器可以容纳的元素个数。这个数必然大于等于size，如果新插入元素的时候size等于capacity，说明已经没有额外空间来存储元素了，就需要扩容。

 

默认的扩容时机 

以下示例在ubuntu 2204上测试

容器初始化为空

  std::vector<int> v0;
  std::cout << "v0 capacity 0: " << v0.capacity() << ", size " << v0.size()
            << std::endl;

  for (int i = 1; i <= 130; ++i) {
    v0.push_back(i);
    std::cout << "v0 capacity " << i << ": " << v0.capacity() << ", size "
              << v0.size() << std::endl;
  }

v0 capacity 0: 0, size 0
v0 capacity 1: 1, size 1
v0 capacity 2: 2, size 2
v0 capacity 3: 4, size 3
v0 capacity 4: 4, size 4
v0 capacity 5: 8, size 5

v0 capacity 8: 8, size 8
v0 capacity 9: 16, size 9
...
v0 capacity 16: 16, size 16
v0 capacity 17: 32, size 17
...
v0 capacity 32: 32, size 32
v0 capacity 33: 64, size 33
...
v0 capacity 64: 64, size 64
v0 capacity 65: 128, size 65
...
v0 capacity 128: 128, size 128
v0 capacity 129: 256, size 129
v0 capacity 130: 256, size 130

可以看出当容器初始化的时候如果没有添加元素，那么容器的扩容时机为元素个数为比0、1、2、4、8 、16 ...这些数多一个的时候扩容。

容器初始化不空

如果vector在初始化的时候提供了元素，那么它的初始容量就是初始化的元素个数。

  std::vector<int> v1{1, 2, 3, 4, 5};
  auto it = v1.begin();

  std::cout << "v1 capacity 1: " << v1.capacity() << ", size " << v1.size()
            << std::endl;
  v1.insert(it + 2, 9); // 在迭代器位置之前插入元素
  std::cout << "v1 capacity 2: " << v1.capacity() << ", size " << v1.size()
            << std::endl;

  std::cout << "--------------------------------------" << std::endl;

  std::vector<int> v3(6, 10);
  std::cout << "v3 capacity 1: " << v3.capacity() << ", size " << v3.size()
            << std::endl;
  for (int i = 1; i <= 20; ++i) {
    v3.push_back(i);
    std::cout << "v3 capacity " << i << ": " << v3.capacity() << ", size "
              << v3.size() << std::endl;
  }

v1 capacity 1: 5, size 5
v1 capacity 2: 10, size 6
--------------------------------------
v3 capacity 1: 6, size 6
v3 capacity 1: 12, size 7
v3 capacity 2: 12, size 8
v3 capacity 3: 12, size 9
v3 capacity 4: 12, size 10
v3 capacity 5: 12, size 11
v3 capacity 6: 12, size 12
v3 capacity 7: 24, size 13
...
v3 capacity 18: 24, size 24
v3 capacity 19: 48, size 25
v3 capacity 20: 48, size 26 

v1 使用初始化列表提供了5个元素， 刚开始的capacity则为5，当插入一个元素的时候capacity立马就发生了变化，自动扩容为10。

v3 使用构造函数指定了6个元素（默认为10），刚开始的capacity则为6，后续在这个基础上扩容。

扩容的后果

所以对vector的任何操作，一旦引起空间重新配置，指向原有vector 的所有迭代器就都失效了。

迭代器失效的问题，本文不讨论，后续我会写相关的文章讨论。

影响capacity的函数

reserve()

函数原型 void reserve( size_type new_cap );

• 将容器扩大到能容纳new_cap的大小
• 扩大的只是容器的预留空间，空间内不正真创建元素对象
• 只可能改变capacity()的返回值——只会增长不会缩小。
• 不改变size()的返回值，即不会改变已经存在的元素。

在前面的基础上修改一下代码

 std::vector<int> v0;
  std::cout << "v0 capacity 0: " << v0.capacity() << ", size " << v0.size()
            << std::endl;

  for (int i = 1; i <= 130; ++i) {
    v0.push_back(i);
    std::cout << "v0 capacity " << i << ": " << v0.capacity() << ", size "
              << v0.size() << std::endl;
  }

  v0.reserve(100);
  std::cout << "after reserve(100) v0 capacity 100: " << v0.capacity()
            << ", size " << v0.size() << std::endl;

  v0.reserve(400);
  std::cout << "after reserve(400) v0 capacity 400: " << v0.capacity()
            << ", size " << v0.size() << std::endl;

查看结果

v0 capacity 129: 256, size 129
v0 capacity 130: 256, size 130
after reserve(100) v0 capacity 100: 256, size 130
after reserve(400) v0 capacity 400: 400, size 130

结论：调用reserve(n)后，若容器的capacity<n，则重新分配内存空间，从而使得capacity等于n。如果capacity>=n呢？capacity无变化。

如果不想在增长过程中频繁移动数据，可以使用reserve来提前预留内存空间。

resize()

函数原型

void resize( size_type count );

void resize( size_type count, const value_type& value );

        即重置容器空间。当设置值小于当前容器空间时，会将目前容器超出部分释放掉；当设置值（及函数的参数）大于当前容器空间时，会在当前空间基础上增加容量。

        第一个参数是指将要扩大到能容纳多少元素的大小；第二个参数是对扩大的空间进行初始化的值，如果不写，默认调用容器中存的元素的默认构造函数。

继续修改刚才的代码

std::vector<int> v0;
  std::cout << "v0 capacity 0: " << v0.capacity() << ", size " << v0.size()
            << std::endl;

  for (int i = 1; i <= 130; ++i) {
    v0.push_back(i);
    std::cout << "v0 capacity " << i << ": " << v0.capacity() << ", size "
              << v0.size() << std::endl;
  }

  v0.resize(100);
  std::cout << "after resize(100) v0 capacity 100: " << v0.capacity()
            << ", size " << v0.size() << std::endl;

  v0.resize(400);
  std::cout << "after resize(400) v0 capacity 400: " << v0.capacity()
            << ", size " << v0.size() << std::endl;

输出

v0 capacity 129: 256, size 129
v0 capacity 130: 256, size 130
after resize(100) v0 capacity 100: 256, size 100
after resize(400) v0 capacity 400: 400, size 400

 结论：调用resize之后，容器的size调整为给定的count 值。容器的capacity取决于调整后的容器的size是否大于capacity。如果调整后size大于capacity，则capacity调整为size大小，否则不变。

vector内存回收

clear()只会清空容器的元素，不会回收内存空间。

reserve()和resize()都只会增长capacity，不会削减其大小，所以不能回收内存。

最好的方式就是和一个空的vector进行swap操作。

  v0.clear();
  std::cout << "after clear capacity: " << v0.capacity() << ", size "
            << v0.size() << std::endl;

  std::vector<int> empty;
  v0.swap(empty);
  std::cout << "after swap capacity: " << v0.capacity() << ", size "
            << v0.size() << std::endl;

查看结果 

after clear capacity: 400, size 0
after swap capacity: 0, size 0