Vector 增长变化

最新推荐文章于 2025-09-18 12:42:27 发布
原创 最新推荐文章于 2025-09-18 12:42:27 发布 · 262 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

VS 2019 亲测 ，绝对详细。

    std::vector<char> v6;
    auto v6_capacity = v6.capacity();
    std::cout << "[V6]:" << std::endl;
    std::cout << "Size:" << v6.size() << "  MaxSize" << v6.max_size() << std::endl;
    std::cout << "Capacity:" << v6.capacity() << std::endl;
    for (int i = 0; i < 1000; i++)
    {
        v6.push_back('1'); //capacity 1, size 1, add allocator 1
        if (v6.capacity() - v6_capacity)
        {
            std::cout << "Size:" << v6.size() << std::endl;
            std::cout << "Capacity:" << v6.capacity() << std::endl;
            std::cout << "add allocated apacity:" << v6.capacity() - v6_capacity << std::endl << std::endl;
        }
        v6_capacity = v6.capacity();
    }

[V6]:
Size:0  MaxSize2147483647
Capacity:0
Size:1
Capacity:1
add allocated apacity:1

Size:2
Capacity:2
add allocated apacity:1

Size:3
Capacity:3
add allocated apacity:1

Size:4
Capacity:4
add allocated apacity:1

Size:5
Capacity:6
add allocated apacity:2

Size:7
Capacity:9
add allocated apacity:3

Size:10
Capacity:13
add allocated apacity:4

Size:14
Capacity:19
add allocated apacity:6

Size:20
Capacity:28
add allocated apacity:9

Size:29
Capacity:42
add allocated apacity:14

Size:43
Capacity:63
add allocated apacity:21

Size:64
Capacity:94
add allocated apacity:31

Size:95
Capacity:141
add allocated apacity:47

Size:142
Capacity:211
add allocated apacity:70

Size:212
Capacity:316
add allocated apacity:105

Size:317
Capacity:474
add allocated apacity:158

Size:475
Capacity:711
add allocated apacity:237

Size:712
Capacity:1066
add allocated apacity:355

刚刚做了一个实验，有人说是增长50%。但是！！！重点来了。具体多少可以自己算，毕竟标准库没有规定，VS2019的capacity增长结果来看：
+1（0.5进位 多计算0.5）A
+1（0.5舍去不进位 补回0.5）B
+1（0.5进位 多计算0.5）A
+1（0.5舍去不进位 补回0.5）B
+2(1整除) 0
+3(1.5进位 多计算0.5) A
+4(整除)
+6(整除)
+9(不进位 补回0.5) B
+14(整除)
+21(进位 多计算0.5) A
+31(不进位 补回0.5) B
+47(进位 多计算0.5) A
+70(整除)
+105(不进位 补回0.5) B
+158(整除)
+237(进位 多计算0.5) A
+355(不进位 补回0.5) B
. 如果前一次4舍5入进位后，下次就4舍5不入，不进位。

为什么要在意这个增长速度呢？

当Vector里面放的东西足够多，足够大时。就会影响效率。
因为Vector 每次增长，会创建一个新的 Vector也就是增长大小以后的Vector，然后会把所有东西都copy过去。然后清除原来的。这样就会造成很多很多次copy，如果是对象会进入多次拷贝构造。
当然如果自定义类型是支持移动构造函数的化，vector的copy会优先使用移动构造来交换。

C++STL教程（23） 研究std::vector的内存增长规律
二进制君
11-21 5979
一、前言 首先说明，vector可以理解为动态数组，既然是数组，那么它在内存中就应该是一块连续的内存，但vector是如何支持动态增长的呢？关于这个问题，网上有很对说法，但其中有些说法是错误的，最近看到有一篇博友的解释就非常正确vector空间动态增长，这里就针对的他的解释进行进一步的阐述，并进行实际验证。 二、vector内存增长方式 C++primer中多次明确指出对vector使用的建议是：先创建一个空的vector对象，然后再运行时再利用vector的成员函数push_back向其中添加元素。先以此
vector的增长机制
Trantor的专栏
03-03 1455
假设我们希望从一个文件中将一串类型为double的值读进一个数据结构中，从而允许我们高效地访问这些值，通常的方法如下：    vector values; double x; while (cin >> x)   values.push_back(x);    当循环结束时，values会容纳有所有的值，我们将可以通过values高效地访问任何值。    在直觉上，标准库vector类
vector扩容因子
weixin_38383877的博客
01-04 569
#include<vector> #include<iostream> using namespace std; int main() { vector<int> v; cout<<v.capacity()<<endl; for(int i=0;i<5;i++) { v.push_back(i); } cout<<v.capacity()<<endl; for(int i=0;i<5;i++).
高性能 Protobuf 用 C++ Arena 把分配与释放速度拉满
最新发布
hello.reader
09-18 899
这是一篇把 C++ Arena Allocation 指南拆成“能上手、可落地”的工程文章。你将看到什么时候该用 Arena、怎么用、生成代码会发生哪些变化、哪些 API 会触发隐式拷贝、如何避免，以及一份可直接照抄的最佳实践清单。
VS2019编译报错：vector不是模板的解决办法
12-23 3127
使用vector出现vector不是模板报错的解决办法
Vector自动增长原理
PinGoole的博客
04-25 905
/*自动增长原理   如果有一个vector容器容量已满  再有一个元素 要往里插  这时就会重新生成一块新内存 一般容量是原来的两倍，把旧的元素拷到新的容器  1 发现空间不足，重新申请一块更大的内存  2 将旧空间的数据拷贝新空间  3 旧空间释放掉   4 将新元素插入到新空间中*/int count = 0; //用来统计重新分配了多少次内存 int* p = NULL; vector...
C++ Vector扩容因子 1.5 2*
qq_45992231的博客
08-28 591
c++ 标准库函数默认情况下提供了合理的性能，但是，如何做到“合理”的呢，read on next. 介绍 假如我们需要从一个文件中读取一组 double 类型的值，并保存在一个数据结构中，我们可以通过以下方式很快速的实现： vector<double> values; double x; while (cin >> x) values.push_back(x); 当循环结束时，values 将保存所有这些值。我们可以通过变量 i 和 values[i] 来快速访问这些值。
vector空间的动态增长
ZX714311728的博客
04-10 4991
vector空间的动态增长     当添加元素时，如果vector空间大小不足，则会以原大小的两倍另外配置一块较大的新空间，然后将原空间内容拷贝过来，在新空间的内容末尾添加元素，并释放原空间。vector的空间动态增加大小，并不是在原空间之后的相邻地址增加新空间，因为vector的空间是线性连续分配的，不能保证原空间之后有可供配置的空间。因此，对vector的任何操作，一旦引起空间的重新配置
C++中vector容器使用详细说明
09-01
它通过动态内存管理来扩展或收缩数组，以适应存储元素数量的变化。`vector`的元素在内存中是连续存储的，这使得它对于随机访问和性能敏感的操作非常高效。 2. **头文件与命名空间** 要使用`vector`，你需要在代码...
【C++】_vector定义、_vector常用方法解析
Become Mad的博客
09-02 3288
学习完了string类，对于vector的学习就显得简单多了。他们的本质都是物理数组，很多的操作也是非常类似的~
C++：vector容器
qq_56146092的博客
08-06 965
std::vector`是C++标准库中的一个序列容器，它代表了能够动态改变大小的数组。与普通数组一样，向量使用连续的存储位置来存放其元素，这使得可以通过指针偏移直接且高效地访问元素，就像操作数组一样。然而，与数组不同的是，向量的大小可以动态变化，其存储管理由容器自动处理。在内部，向量使用动态分配的数组来存储元素。为了适应增长，这个数组可能需要重新分配空间，这意味着创建一个新的数组并将所有元素移动到新位置。由于重新分配涉及大量的计算资源，向量并不会在每次插入新元素时都重新分配内存。相反，
vector的pushback函数使用之后是不是vector的大小自动变化 不需要resize
05-09
当$vector$的容量（`capacity()`）不足以容纳新元素时，会自动触发内存重新分配（通常按**指数级增长策略**，如VS默认扩容1.5倍，GCC扩容2倍）。 - 扩容过程包括： - 分配新内存块 - 将旧元素移动/拷贝到新内存 ...
WindowsVS2019环境下C++编译GSL库动态库静态库
04-27
我想做一个最小二乘法正太拟合曲线，网上都是python调用matlab进行拟合，我想用C++拟合曲线，发现网上有开源库GSL也有计算方法；这工程就是用VS2019编译的GSL动态库，测试项目中包括GSL生成的动态库静态库。
Vector
在数字时代,软件的名字就是脆弱,代码会随着时间流逝而烂掉
02-06 441
2.Vector 是多线程安全的，线程安全就是说多线程访问同一代码，不会产生不确定的结果，而 ArrayList 不是，这个可以从源码中看出，Vector 类中的方法很多有 synchronized 进行修饰，这样就导致了 Vector 在效率上无法与 ArrayList 相比【第二张图能体现】● 以2倍的方式扩容，导致下一次申请的内存必然大于之前分配内存的总和，导致之前分配的内存不能再被使用，所以最好倍增长因子设置为(1,2)之间。4.因为考虑到线程安全的问题，效率比较低。可以用什么代替Vector。
9.4vector对象是如何增长的
weixin_44897707的博客
10-20 239
vector对象是如何增长的 为了支持快速随机访问，vector元素类似数组一样是连续存储的。但是与数组不同，vector或string的容器大小是可变的。因此，vector和string当没有空间容纳新元素时，将已有元素从旧位置移动到新空间中（通过右值引用实现），然后添加新元素，释放旧存储空间。但如果我们每添加一个新元素就执行一次这样的内存分配和释放，性能会很慢，因此，当不得不获取新的内存空间时，vector和string的实现通常会分配比新的空间需求更大的内存空间。 1.管理容器的成员函数 vector
vector容器的自增长
洛冰翼的专栏
02-28 457
1.vector 是用数组做出来的     数组的有点和缺点 2. capacity和reserve成员
vector的size和capacity改变时空间分配的过程
说自己行就行
04-29 640
当增加新元素（s）时，如果超过当时的容量，则容量会扩充至两倍。如果两倍容量仍不足，就扩张至足够大的容量。 以一个例子来说明： #include #include #include using namespace std; int main() { int i; vector iv(2,9); cout<<"size = "<<iv.size()<<endl;
1.29.2019 vector
AndyZZhang的博客
01-30 226
实例化：编译器根据模板创建类或函数的过程。vector是模板而非类型。 引用不是对象，不存在包含引用的vector。 vector的初始化：列表初始化、（n,内容）、值初始化（0、空） {}：内容。构造vector初值。列表初始化。 （）：数量。构造vector对象容量。 string：只能使用{数字：容量、“”内容}，不能使用字面值构建vector对象。 push_back ：负责把一个值当成v...
2019年一文读懂Vector
Hongdou的博客
11-03 400
Vector Vector一、简介1.1 源码分析1.2 使用建议二、特点2.1 初始化 Vector 的大小，未指定时默认是102.2 数据都存储在数组中2.3 扩容第一种情况：默认构造函数第二种情况：自定义初始容量的构造函数第三种情况：自定义初始容量 和 扩容大小的构造函数第四种情况：传入 Collection 集合方式的构造函数注意：为什么要将大小减8？ 一、简介 Vector底层的数...
vector 空间增长规则
08-09
<think>我们正在讨论C++ vector的动态扩容机制。根据引用内容，vector的扩容机制主要涉及以下几个方面： 1. **扩容触发条件**：当向vector中添加元素（如push_back）导致当前大小(size)等于容量(capacity)时，就会触发扩容[^3]。 2. **扩容策略**：通常采用固定倍数扩容（如2倍）[^2][^3]，但具体实现可能因编译器和版本而异。 3. **扩容过程**： - 分配新的内存空间（大小为原容量的固定倍数） - 将原有元素移动到新空间（逐个拷贝或移动） - 释放原有内存空间 - 更新内部指针（起始位置、结束位置和容量指针）[^3] 4. **扩容对迭代器的影响**：扩容后元素的内存地址发生变化，导致原有迭代器失效[^5]。 ### 扩容机制详解 #### 1. 扩容倍数 - **常见策略**：大多数标准库实现（如GCC的libstdc++、Clang的libc++）采用**2倍扩容**（geometric growth）[^2][^3]。 - **数学原理**：假设初始容量为$c$，经过$k$次扩容后总容量为$c \times 2^k$。这种策略的均摊时间复杂度为$O(1)$（详见下文分析）。 #### 2. 扩容过程示例 参考用户提供的代码[^1]： ```cpp #include <iostream> #include <vector> int main() { std::vector<int> vec; int capacity = -1; std::cout << "size: " << vec.size() << " capacity: " << vec.capacity() << std::endl; for (int i = 0; i < 500; i++) { vec.push_back(i); if (capacity != vec.capacity()) { std::cout << "size: " << vec.size() << " capacity: " << vec.capacity() << std::endl; capacity = vec.capacity(); } } return 0; } ``` 运行结果可能如下（不同编译器输出不同）： ``` size: 0 capacity: 0 size: 1 capacity: 1 // 插入第一个元素，扩容至1 size: 2 capacity: 2 // 插入第二个元素，扩容至2 size: 3 capacity: 4 // 插入第三个元素，扩容至4 size: 5 capacity: 8 // 插入第五个元素，扩容至8 size: 9 capacity: 16 // ... ... size: 17 capacity: 32 size: 33 capacity: 64 size: 65 capacity: 128 size: 129 capacity: 256 size: 257 capacity: 512 ``` **规律**：每次扩容时，新容量 = max(当前容量×2, 所需最小容量)[^3]。 #### 3. 时间复杂度分析 - **单次插入的最坏情况**：$O(n)$（需要移动所有元素） - **均摊时间复杂度**：$O(1)$（使用均摊分析法） **证明**（简化版）： 设初始容量为1，插入$n$个元素的总操作次数（包括复制元素）为： $$ T(n) = 1 + 2 + 4 + ... + 2^{\lfloor \log_2 n \rfloor} + n \approx 2n $$ > 解释： > - 扩容时的复制操作：第$i$次扩容复制$2^i$个元素（$i=0,1,2,...,k$，其中$2^k < n \leq 2^{k+1}$） > - 总复制量：$\sum_{i=0}^{k} 2^i = 2^{k+1} - 1 < 2n$ > - 总操作量 = 复制操作 + 插入操作 < $2n + n = 3n$ > 因此每次插入的均摊成本为$O(1)$[^4]。 #### 4. 空间复杂度 - 最坏情况：$O(n)$（与元素数量线性相关） - 实际占用空间：$O(n)$（容量最多为$2n$） #### 5. 迭代器失效问题 扩容后元素被移动到新内存地址，导致： - 所有迭代器（包括begin/end）、引用和指针失效[^5] - 示例： ```cpp std::vector<int> v = {1,2,3}; auto it = v.begin(); v.push_back(4); // 可能触发扩容，导致it失效 // 错误！不能使用失效的迭代器 std::cout << *it << std::endl; ``` ### 不同实现的扩容策略 | 标准库实现 | 扩容倍数 | 特殊规则 | |------------------|----------|------------------------------| | GCC (libstdc++) | 2倍 | 初始空容量为0 | | Clang (libc++) | 2倍 | 初始空容量为0 | | MSVC (VS 2022) | 1.5倍 | 初始空容量为0，之后按1.5倍增 | > 注：C++标准未规定具体倍数，由实现决定[^3]。 ### 性能优化建议 1. **预分配空间**：若已知元素数量$n$，提前调用`reserve(n)`避免多次扩容[^3]。 2. **避免在循环中插入**：多次`push_back`可能触发多次扩容。 3. **使用移动语义**：对于复杂对象，实现移动构造函数减少复制开销。 ### 手动实现动态数组（简化版） 参考C语言实现思路[^1]： ```c typedef struct { int* data; size_t size; size_t capacity; } IntVector; void push_back(IntVector* vec, int value) { if (vec->size == vec->capacity) { size_t new_cap = (vec->capacity == 0) ? 1 : vec->capacity * 2; int* new_data = realloc(vec->data, new_cap * sizeof(int)); if (!new_data) abort(); vec->data = new_data; vec->capacity = new_cap; } vec->data[vec->size++] = value; } ``` ### 总结 | 关键特性 | 说明 | |------------------|----------------------------------------------------------------------| | 触发条件 | size == capacity 时插入新元素 | | 扩容倍数 | 通常为2倍（GCC/Clang）或1.5倍（MSVC） | | 时间复杂度 | 单次插入最坏$O(n)$，均摊$O(1)$ | | 空间复杂度 | $O(n)$ | | 迭代器失效 | 扩容后所有迭代器、引用、指针失效 | | 优化方法 | 使用`reserve()`预分配空间 | --- §§相关问题§§ 1. 为什么C++ vector选择2倍（或1.5倍）扩容而不是固定增量扩容？ 2. 如何验证当前编译器使用的vector扩容策略？ 3. vector的`resize()`和`reserve()`方法有什么区别？ 4. 在频繁插入元素的场景下，如何避免vector扩容导致的性能下降？ 5. 其他STL容器（如deque、list）的存储机制与vector有何不同？</think>### C++ vector 动态扩容机制详解 C++ 中的 `std::vector` 采用动态数组实现，其核心特性是**自动扩容**机制。当元素数量超过当前容量时，vector 会自动分配更大的内存空间并迁移数据。以下是详细机制分析： --- #### 1. **扩容触发条件** - 当调用 `push_back()`、`insert()` 或 `emplace_back()` 等方法添加新元素时，如果当前元素数量（`size()`）等于当前容量（`capacity()`），则会触发扩容[^3]。 - **示例**： ```cpp std::vector<int> vec; vec.push_back(1); // size=1, capacity=1（首次触发） vec.push_back(2); // size=2 > capacity=1 → 扩容 ``` --- #### 2. **扩容策略：固定倍数增长** vector 采用**几何增长（Geometric Growth）**策略，通常按当前容量的固定倍数扩容： - **常见倍数**： - GCC/Clang：**2 倍扩容**（主流实现）[^2][^3] - MSVC：**1.5 倍扩容**（Visual Studio 实现） - **扩容过程**： 1. 分配新内存（大小为旧容量的 $k$ 倍） 2. 将旧元素**逐个移动或拷贝**到新内存 3. 释放旧内存 4. 更新容量指针[^3] --- #### 3. **扩容过程示例 通过代码观察扩容行为[^1]： ```cpp #include <iostream> #include <vector> int main() { std::vector<int> vec; int prev_cap = -1; for (int i = 0; i < 10; i++) { vec.push_back(i); if (prev_cap != vec.capacity()) { std::cout << "Size: " << vec.size() << " | Capacity: " << vec.capacity() << std::endl; prev_cap = vec.capacity(); } } } ``` **输出示例（GCC）**： ``` Size: 1 | Capacity: 1 // 初始 Size: 2 | Capacity: 2 // 2倍扩容 Size: 3 | Capacity: 4 // 2倍扩容 Size: 5 | Capacity: 8 // 2倍扩容 Size: 9 | Capacity: 16 // 2倍扩容 ``` --- #### 4. **时间复杂度分析** - **单次插入最坏情况**：$O(n)$（需移动所有元素） - **均摊时间复杂度**：$O(1)$（通过均摊分析证明） **数学证明**（以2倍扩容为例）： 设初始容量为 $1$，插入 $n$ 个元素的总操作次数为： $$ T(n) = 1 + 2 + 4 + \cdots + 2^{\lfloor \log_2 n \rfloor} + n \leq 2n $$ 均摊到每次插入：$\frac{T(n)}{n} \leq 2 = O(1)$[^4]。 --- #### 5. **关键特性** - **迭代器失效**：扩容后元素地址改变，所有迭代器、指针、引用失效[^5]。 - **空间利用率**：容量总是 $2^k$ 形式，可能造成最多 **50% 的空间浪费**（如 capacity=8 时实际只用 5 个位置）。 - **默认初始容量**：空 vector 的 `capacity()` 通常为 0[^1]。 --- #### 6. **优化建议** 1. **预分配空间**：若已知元素数量 $n$，提前调用 `reserve(n)` 避免多次扩容[^3]。 ```cpp std::vector<int> vec; vec.reserve(100); // 一次性分配100个元素空间 ``` 2. **避免频繁插入**：批量插入优于单元素多次插入。 3. **移动语义**：对复杂对象使用 `std::move` 减少拷贝开销。 --- #### 不同编译器实现对比 | 编译器 | 扩容倍数 | 初始容量 | 扩容触发条件 | |-------------|----------|----------|--------------------| | GCC/Clang | 2.0× | 0 | size == capacity | | MSVC | 1.5× | 0 | size == capacity | ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值