C++ vector 内存分配与回收机制

╰半橙微兮° 2022-06-09 13:24 737阅读 0赞

原文出处：[http://blog.csdn.net/qq\_30835655/article/details/60762196][http_blog.csdn.net_qq_30835655_article_details_60762196]

最近开始更加深入的学习C++，发现了很多以前没注意到但是很重要的知识点。这篇文章主要说vector内存机制和效率问题。

## 1. vector内存增长 ##

vector所有的内存相关问题都可以归结于它的内存增长策略。vector有一个特点就是：内存空间只会增长不会减少。vector有两个函数，一个是**capacity()**，返回对象缓冲区（vector维护的内存空间）实际申请的空间大小，另一个**size()**，返回当前对象缓冲区存储数据的个数。对于vector来说，capacity是永远大于等于size的，但capacity和size相等时，vector就会扩容，**capacity**变大。

比如说vector最常用的**push\_back**操作，它的整个过程是怎么一个机制呢？这个问题经常在面试中出现。

这个问题其实很简单，在调用**push\_back**时，若当前容量已经不能够放入新的元素（capacity=size），那么vector会重新申请一块内存，把之前的内存里的元素拷贝到新的内存当中，然后把push\_back的元素拷贝到新的内存中，最后要析构原有的vector并释放原有的内存。所以说这个过程的效率是极低的，为了避免频繁的分配内存，C++每次申请内存都会成倍的增长，例如之前是4，那么重新申请后就是8，以此类推。当然不一定是成倍增长，比如在我的编译器环境下实测是0.5倍增长，之前是4，重新申请后就是6。

编译环境：visual studio 2015

**接下来我们通过一个简单的程序实例来观察这个过程。**

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include<vector>  
2.  \#include<iostream>  
3.  **using** **namespace** std;  
4.  **class** Point  
5.  \{  
6.  **public**:  
7.      Point()  
8.      \{  
9.          cout << "construction" << endl;  
10.     \}  
11.     Point(**const** Point& p)  
12.     \{  
13.         cout << "copy construction" << endl;  
14.     \}  
15.     ~Point()  
16.     \{  
17.         cout << "destruction" << endl;  
18.     \}  
19. \};  
20. **int** main()  
21. \{  
22.     Point test\[10\];  
23.     cout << "\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*" << endl;  
24.     vector<Point> arr;  
25.     **for** (**int** i = 0; i < 10; i++)  
26.     \{  
27.         arr.push\_back(test\[i\]);  
28.         cout << "capacity=" << arr.capacity() << ",size=" << arr.size() << endl;  
29.         cout << "--------------------------" << endl;  
30.     \}  
31.     system("pause");  
32. \}

程序运行结果

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  construction  
2.  construction  
3.  construction  
4.  construction  
5.  construction  
6.  construction  
7.  construction  
8.  construction  
9.  construction  
10. construction  
11. \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
12. copy construction  
13. capacity=1,size=1  
14. \--------------------------  
15. copy construction  
16. destruction  
17. copy construction  
18. capacity=2,size=2  
19. \--------------------------  
20. copy construction  
21. copy construction  
22. destruction  
23. destruction  
24. copy construction  
25. capacity=3,size=3  
26. \--------------------------  
27. copy construction  
28. copy construction  
29. copy construction  
30. destruction  
31. destruction  
32. destruction  
33. copy construction  
34. capacity=4,size=4  
35. \--------------------------  
36. copy construction  
37. copy construction  
38. copy construction  
39. copy construction  
40. destruction  
41. destruction  
42. destruction  
43. destruction  
44. copy construction  
45. capacity=6,size=5  
46. \--------------------------  
47. copy construction  
48. capacity=6,size=6  
49. \--------------------------  
50. copy construction  
51. copy construction  
52. copy construction  
53. copy construction  
54. copy construction  
55. copy construction  
56. destruction  
57. destruction  
58. destruction  
59. destruction  
60. destruction  
61. destruction  
62. copy construction  
63. capacity=9,size=7  
64. \--------------------------  
65. copy construction  
66. capacity=9,size=8  
67. \--------------------------  
68. copy construction  
69. capacity=9,size=9  
70. \--------------------------  
71. copy construction  
72. copy construction  
73. copy construction  
74. copy construction  
75. copy construction  
76. copy construction  
77. copy construction  
78. copy construction  
79. copy construction  
80. destruction  
81. destruction  
82. destruction  
83. destruction  
84. destruction  
85. destruction  
86. destruction  
87. destruction  
88. destruction  
89. copy construction  
90. capacity=13,size=10  
91. \--------------------------

程序运行结果简单明了，但是有一点令人很不解，vector原空间的析构居然是在新元素的push\_back前面发生，与网上查询资料有所不同。有待考证，希望阅读者可以在自己的环境下测试，观察结果。

## 2. 内存释放 ##

就像前面所说的，vector的内存空间是只增加不减少的，我们常用的操作clear()和erase()，实际上只是减少了size()，清除了数据，并不会减少capacity，所以内存空间没有减少。那么如何释放内存空间呢，正确的做法是swap()操作。

标准模板如下

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **template** < **class** T >  
2.  **void** ClearVector( vector< T >& vt )   
3.  \{  
4.      vector< T > vtTemp;   
5.      veTemp.swap( vt );  
6.  \}

也可以简单使用以下操作

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  vector<Point>().swap(pointVec); //或者pointVec.swap(vector<Point> ())

swap交换技巧实现内存释放思想：vector()使用vector的默认构造函数建立临时vector对象，再在该临时对象上调用swap成员，swap调用之后原来vector占用的空间就等于一个默认构造的对象的大小，临时对象就具有原来对象v的大小，而该临时对象随即就会被析构，从而其占用的空间也被释放。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  std::vector<T>().swap(X)  
2.  作用相当于：  
3.  \{  
4.  std::vector<T>  temp(X);  
5.  temp.swap(X);  
6.  \}

交换之后，temp会被析构。

## 3.总结 ##

由上可见，vector虽然是动态数组，但是本质上和数组没什么区别，频繁的销毁新建，效率很低，所以正确的做法是新建vector的时候初始化一个合适的大小（**笑**），回到了数组的老路上。不过之后可以动态变化还是很方便，而且还有很多好用的函数。

vecotr是动态数组，顾名思义他可以动态的增加自己的长度。

**内存机制：**

但是怎样的增加自己的长度？

vector有两个函数一个是capacity()返回内存空间即缓冲区的大小，另一个是size()返回当前数组中数的数量。vector增加元素来说，当容量已经不能放进数据了，那么他会重新申请一块内存，把之前的内存利用复制构造函数复制到新的内存当中，然后把新添加的内容放入后面，另外此时的他申请的内存空间是原来空间的2倍，我测得是2倍

[ 下文出处：http://www.cnblogs.com/zhaopAC/p/5404828.html][http_www.cnblogs.com_zhaopAC_p_5404828.html]

缓冲区的释放

vecotor占用的内存只增不减，erase只是将一段区间（ earse(arr.begin(), arr.end() ）的值清除掉或者将某个值( erase(x) )清除掉，但是对于内存空间来说是没变化的

所有内存空间是在vector析构时候才能被系统回收。empty()用来检测容器是否为空的，clear()可以清空所有元素。但是即使clear()，vector所占用的内存空间依然如故，无法保证内存的回收。

![复制代码][copycode.gif]

方法一:
    vecotr<Type>().swap(arr) // 回收arr内存
    方法二：
    模板：
    Template < class T >
    void ClearVector( vector< T >& vt ) 
    {
        vector< T > vtTemp; 
        veTemp.swap( vt );
    }
    调用模板函数
    void ClearVector<vector< T> & vt)
    {  
        vector<int> temp;//临时对象未初始化，其缓冲区大小为0，没有数据  
        arr.swap(temp);//与我们的对象交换数据，arr的缓冲区就没了。  
    }//临时变量会被析构，temp调用vector析构函数释放空间

![复制代码][copycode.gif]

\----------------------------------------------------------------------------

性能分析：

主要比较三种插入方式：

1、直接push\_back（） 2、 reserve(n) 预定n个空间，当然后续push\_back()会增加，其中的值不确定， 3 resize(n, x)  申请n个空间初始化为x，

reserve只是保持一个最小的空间大小，而resize则是对缓冲区进行重新分配，里面涉及到的判断和内存处理比较多所以比reserve慢一些，对于数据数目可以确定的时候，先预设空间大小是很有必要的。直接push\_back数据频繁移动很是耗时

[http_blog.csdn.net_qq_30835655_article_details_60762196]: http://blog.csdn.net/qq_30835655/article/details/60762196
[view plain]: http://blog.csdn.net/qq_30835655/article/details/60762196#
[http_www.cnblogs.com_zhaopAC_p_5404828.html]: http://www.cnblogs.com/zhaopAC/p/5404828.html
[copycode.gif]: /images/20220609/9289ebe2392c46fa81b59ca67d9e6ced.png

发表评论取消回复

表情：

评论列表（有 0 条评论，737人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java虚拟机内存分配与回收机制分析

在Java编程中，Java虚拟机（JVM）的内存管理扮演了至关重要的角色。下面将详细分析其内存分配与回收机制。 1. 内存区域： - 堆区：主要存放对象实例。垃圾回收器

旧城等待，/ 2024年09月19日 18:39/ 0 赞/ 79 阅读

相关 JVM内存分配与回收机制解析案例

在Java虚拟机（JVM）的内存分配与回收机制中，主要包括以下几个部分： 1. **堆内存（Heap）**：这是JVM用来存储对象实例的主要区域。当程序创建一个新的对象时，这

ゝ一纸荒年。/ 2024年09月18日 21:03/ 0 赞/ 67 阅读

相关 JVM内存分配与回收机制详解

Java Virtual Machine (JVM)的内存分配和回收机制是保证程序运行稳定和高效的重要部分。以下是详尽解释： 1. **堆（Heap）**：这是JVM管理的主

分手后的思念是犯贱/ 2024年09月18日 06:00/ 0 赞/ 79 阅读

相关垃圾回收与内存分配

文章目录查看本地虚拟机版本堆空间的基本结构内存分配和回收策略主要进行GC的区域内存分配策略对象

悠悠/ 2024年02月20日 12:42/ 0 赞/ 89 阅读

相关 JVM——垃圾回收机制与内存分配模型

JVM——垃圾回收机制与内存分配模型 > 什么内存区域的对象需要使用垃圾回收机制回收？前言：线程私有的内存区域的生命周期随线程而生，随线程而灭。分配

╰+攻爆jí腚メ/ 2023年06月08日 10:52/ 0 赞/ 74 阅读

相关 JVM——内存分配与回收

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4

刺骨的言语ヽ痛彻心扉/ 2023年06月05日 11:09/ 0 赞/ 42 阅读

相关 C++ vector 内存分配与回收机制

原文出处：[http://blog.csdn.net/qq\_30835655/article/details/60762196][http_blog.csdn.net_qq_

╰半橙微兮°/ 2022年06月09日 13:24/ 0 赞/ 738 阅读

相关内存分配与回收策略

内存分配与回收策略（1）对象优先在Eden分配（2）大对象直接进入老年代（3）长期存活的对象将进入老年代（4

矫情吗；*/ 2022年03月10日 13:42/ 0 赞/ 373 阅读

相关 linux内存分配与回收

前言之前在实习时，听了 OOM 的分享之后，就对 Linux 内核内存管理充满兴趣，但是这块知识非常庞大，没有一定积累，不敢写下，担心误人子弟，所以经过一个一段时间的积累，

你的名字/ 2022年02月04日 02:15/ 0 赞/ 242 阅读

相关 JVM内存分配与回收

JVM内存分配与回收概述 Java堆空间对象优先在Eden区分配大对象直接进入老年代长期存活的对象将进入老年代动态对象年龄判

水深无声/ 2021年11月09日 11:06/ 0 赞/ 429 阅读