2. 程式人生 > >STL中vector的記憶體分配機制

STL中vector的記憶體分配機制

阿新 • • 發佈：2019-01-30
一些好的公司校園招聘過程中（包括筆試、面試環節），經常會涉及到STL中vector的使用（主要是筆試）及其效能（面試）的分析。今天看了下相關文章，也寫了幾個小的測試程式跑了跑。算是總結下，希望對需要的人有幫助。

關於vector，簡單地講就是一個動態陣列，裡面有一個指標指向一片連續的記憶體空間，當空間不夠裝下資料時會自動申請另一片更大的空間，然後把原有資料拷貝過去，接著釋放原來的那片空間（所以之前引用的vector的地址就失效了，不能訪問了）；當釋放或者說是刪除裡面的資料時，其儲存空間並不會釋放，僅僅只是清空了裡面的資料。接下來，我會詳細地說說這些。

備註：本文的相關程式都是在windows 7+VS2008環境下測試。

一、首先，看看vector的記憶體分配機制：
  1. vector<int> arr;  
  2. ofstream wf("1.txt");  
  3. for(int i=0;i<100;++i)  
  4. {  
  5.     arr.push_back(i);  
  6.     wf<<"capacity="<<arr.capacity()<<",size="<<arr.size()<<end;  
  7. }  
  8. wf.close();  
capacity()返回的是當前vector物件緩衝區（後面的對vector維護的記憶體空間皆稱為緩衝區）實際申請的空間大小，而size()返回的是當前物件緩衝區中儲存資料的個數，capacity永遠是大於等於size的，當size和capacity相等時繼續新增資料時vector會擴容。

再來看看1.txt中的資料：

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

資料有點多，提煉下就是這樣的：

capacity=1
capacity=2
capacity=3
capacity=4
capacity=6
capacity=9
capacity=13
capacity=19
capacity=28
capacity=42
capacity=63
capacity=94
capacity=141

看出其中的規律沒？對，就是每次擴容都是增加當前空間的50%(第一次除外);（也有人說記憶體的增量取決於實現，在不同的編譯器中可能就是capacity*2）

9+9/2=13;13+13/2=19;19+19/2=28……

其實STL的原始碼我們都可以看到的，具體就在你說安裝的編譯器目錄下，例如，我的VS2008是在：安裝目錄\VC\include下面。你也可以在VS中直接選中#include <vector>右鍵開啟。當然了，windows上的STL原始碼都是P.J. Plauger寫的（PS:很牛B的博士，百度你就知道），大家都說可讀性極差，我也這麼認為，我們這些菜鳥還是看GCC中的STL原始碼吧。

\VC\include\vector中是這樣擴容的：

  1. <span style="white-space:pre">      </span>if (_Count == 0)//這裡進行了判斷，但是什麼都不做，不知道為什麼？？？？？？？
  2.             ;  
  3.         elseif (max_size() - size() < _Count)//編譯器可以申請的最大容量也裝不下，丟擲異常_THROW(length_error, "vector<T> too long");
  4.             _Xlen();    // result too long
  5.         elseif (_Capacity < size() + _Count)//當前空間不足，需要擴容
  6.             {   // not enough room, reallocate
  7.             _Capacity = max_size() - _Capacity / 2 < _Capacity  
  8.                 ? 0 : _Capacity + _Capacity / 2;    // try to grow by 50%，擴容50%
  9.             if (_Capacity < size() + _Count)//擴容50%後依然不夠容下，則使容量等於當前資料個數加上新增資料個數
  10.                 _Capacity = size() + _Count;  
  11.             pointer _Newvec = this->_Alval.allocate(_Capacity);//申請新的空間
  12.             pointer _Ptr = _Newvec;  
  13.             _TRY_BEGIN  
  14.             _Ptr = _Umove(_Myfirst, _VEC_ITER_BASE(_Where),  
  15.                 _Newvec);   // copy prefix  <span style="white-space:pre">  </span>//拷貝原有資料到新的記憶體中
  16.             _Ptr = _Ucopy(_First, _Last, _Ptr); // add new stuff<span style="white-space:pre">  </span>//拷貝新增資料到新的記憶體的後面
  17.             _Umove(_VEC_ITER_BASE(_Where), _Mylast, _Ptr);  // copy suffix
  18.             _CATCH_ALL  
  19.             _Destroy(_Newvec, _Ptr);  
  20.             this->_Alval.deallocate(_Newvec, _Capacity);//釋放原來申請的記憶體
  21.             _RERAISE;  
  22.             _CATCH_END  
對的，就是每次擴容50%。至於刪除容器中資料的時候，緩衝區大小並不會改變，僅僅只是清楚了其中的資料，只有在解構函式呼叫的時候vector才會自動釋放緩衝區。

看看它的析構程式碼：

  1. ~vector()  
  2.     {   // destroy the object
  3.     _Tidy();  
  4.     }  
  1. <span style="white-space:pre">  </span>void _Tidy()  
  2. <span style="white-space:pre">      </span>{<span style="white-space:pre">  </span>// free all storage
  3. <span style="white-space:pre">      </span>if (_Myfirst != 0)  
  4. <span style="white-space:pre">          </span>{<span style="white-space:pre">  </span>// something to free, destroy and deallocate it
  5.  #if _HAS_ITERATOR_DEBUGGING  
  6. <span style="white-space:pre">          </span>this->_Orphan_all();  
  7.  #endif /* _HAS_ITERATOR_DEBUGGING */
  8. <span style="white-space:pre">          </span>_Destroy(_Myfirst, _Mylast);//應該是銷燬vector中的每一個元素吧
  9. <span style="white-space:pre">          </span>this->_Alval.deallocate(_Myfirst, _Myend - _Myfirst);//釋放緩衝區的空間
  10. <span style="white-space:pre">          </span>}  
  11. <span style="white-space:pre">      </span>_Myfirst = 0, _Mylast = 0, _Myend = 0;//指標全部歸零
  12. <span style="white-space:pre">      </span>}  
那麼，我們可以在需要的時候強制釋放緩衝區不？

二、如何強制釋放vector的緩衝區:

答案是可以的，既然析構時會釋放空間，那麼我們就可以換個方式呼叫解構函式。

  1. //  //方法一、
  1.     vector<int>().swap(arr); //交換後
  2. //方法二、
  3. {  
  4.     vector<int> temp;//臨時物件未初始化，其緩衝區大小為0，沒有資料  本人註釋：vector<int>temp=arr;                      //這樣swap之後arr才能保留原來的元素，並且收縮到合適的大小
  5.     arr.swap(temp);//與我們的物件交換資料，arr的緩衝區就沒了。
  6. }//臨時變數會被析構，temp呼叫vector解構函式釋放空間

swap交換技巧實現記憶體釋放思想：vector()使用vector的預設建構函式建立臨時vector物件，再在該臨時物件上呼叫swap成員，swap呼叫之後物件myvector佔用的空間就等於一個預設構造的物件的大小，臨時物件就具有原來物件v的大小，而該臨時物件隨即就會被析構，從而其佔用的空間也被釋放。程式碼如下（http://blog.csdn.net/sunmenggmail/article/details/8605538）：

  1. vector< T >().swap(X)  
        下面我們通過一個簡單的示例來show一下：
  1. /******************************************************************* 
  2.  * Copyright (C) Jerry Jiang 
  3.  *                
  4.  * File Name   : swap.cpp 
  5.  * Author      : Jerry Jiang 
  6.  * Create Time : 2012-3-24 4:19:31 
  7.  * Mail        : [email protected] 
  8.  * Blog        : http://blog.csdn.net/jerryjbiao  
  9.  *                
  10.  * Description : 簡單的程式詮釋C++ STL算法系列之十五                   
  11.  *               成員函式swap實現容器的記憶體釋放    
  12.  *                
  13.  ******************************************************************/
  14. #include <iostream>
  15. #include <algorithm>
  16. #include <vector>
  17. #include <iterator>
  18. usingnamespace std;  
  19. int main ()   
  20. {  
  21.     int x = 10;  
  22.     vector<int> myvector(10000, x);    
  23.     //這裡列印僅僅是元素的個數不是記憶體大小
  24.     cout << "myvector size:"
  25.          << myvector.size()  
  26.          << endl;  
  27.     //swap交換函式釋放記憶體：vector<T>().swap(X);
  28.     //T:int ; myvertor代表X
  29.     vector<int>().swap(myvector);  
  30.     //兩個輸出僅用來表示swap前後的變化
  31.     cout << "after swap :"
  32.          << myvector.size()  
  33.          << endl;  
  34.     return 0;  
  35. } 

 本人註釋：我發現很多文章可能在轉載的過程中出錯了，因為這樣swap的話，myvector就被清空了，而不是把記憶體收縮到合適，原來的元素也沒保留，我通過除錯和檢視別的文章發現，應該對上述程式碼做如下修改：

#include <iostream>  
#include <algorithm>  
#include <vector>  
#include <iterator>  

using namespace std;

int main()
{
	int x = 10;
	vector<int> myvector;
	myvector.push_back(1);
	myvector.push_back(1);
	myvector.push_back(1);
	myvector.push_back(1);
	myvector.push_back(1);
	//列印元素的個數和容量大小 
	cout << "myvector size:"
		<< myvector.size()
		<< endl;
	cout << "myvector capacity:"
		<< myvector.capacity()
		<< endl;
	vector<int>(myvector).swap(myvector);

	//兩個輸出用來表示swap前後的變化  
	cout << "after swap :"
		<< myvector.size() << " "
		<< myvector.capa

相關推薦

C++中vector記憶體擴充機制

為了支援隨機訪問，vector中的元素採用順序存放，即每一個元素緊挨著前一個元素進行儲存。那麼現在只有可能出現問題了，當記憶體中沒有足夠連續的空間去存放新插入來的元素怎麼辦，C++是這樣處理的：重新分配記憶體空間，將原來舊的元素全部複製到新的儲存空間中去，然後再插入新的元素

STL中vector的記憶體分配機制

一些好的公司校園招聘過程中（包括筆試、面試環節），經常會涉及到STL中vector的使用（主要是筆試）及其效能（面試）的分析。今天看了下相關文章，也寫了幾個小的測試程式跑了跑。算是總結下，希望對需要的人有幫助。 關於vector，簡單地講就是一個動態陣列，裡面有一個指標

STL中vector的記憶體分配與正確釋放

1.vector的記憶體增長 vector其中一個特點：記憶體空間只會增長，不會減小，援引C++ Primer：為了支援快速的隨機訪問，vector容器的元素以連續方式存放，每一個元素都緊挨著前一個元素儲存。設想一下，當vector新增一個元素時，為了滿足連續存放這個特性，都需要重新分配空間、拷貝元素、撤

記憶體探尋1之——值型別和引用型別的記憶體分配機制

String物件和值型別的記憶體分配機制：           同樣由前延伸，上上篇《由String型別分析，所產生的對引數傳遞之惑的解答》中，最後提及，如果將引用型別的按值傳遞和按引用傳遞，用託管堆表

Java中的記憶體分配以及棧和堆的區別

Java中的記憶體分配以及棧和堆的區別 (1)棧: 存放的是區域性變數 區域性變數：在方法定義中或者方法宣告上的變數都是區域性變數。 (2)堆: 存放的是所有new出來的東西 特點： a: 每一個new出來的東西都會為其分配一個地制值。 b: 每

Objective-C中的記憶體管理機制

從蘋果的官方文件來看，OC對應用程式的記憶體管理提供了2種方法。 第一種即“manual retain-release”（MRR），手動保留釋放，也可理解為手動引用計數。 第二種，“Automatic Reference Counting”（ARC），自動引用計數。但是ARC並不等同垃圾回收。在蘋果的官方

Java例項化物件過程中的記憶體分配

問題引入 這裡先定義一個很不標準的“書”類,這裡為了方便演示就不對類的屬性進行封裝了。 class Book{ String name; //書名 double price; //價格 public void getIn

C++STL中vector容器 begin()與end()函式、front()與back()

begin函式： 函式原型: iterator begin(); const_iterator begin(); 功能： 返回一個當前vector容器中起始元素的迭代器。 end函式： 函式原型： iterator end(); const_iterat

一個程式包含C++ STL中vector常見用法

廢話少說，直接上程式碼：  #include <iostream> #include <vector> using namespace std; int main() { //vector的四種構造方式 //構造一個空vector vect

C/C++程式中的記憶體分配

有人說，一個學習過C語言的人，在看到程式碼時，看到的不是程式碼，而是一塊又一塊的記憶體，那麼一個由C/C++編譯的程式佔用的記憶體分為哪幾個部分呢？ 1.棧區(Stack)：由編譯器自動分配釋放，存放的是為執行函式而分配的區域性變數、函式的引數、返回的資料、返回的地址等等，它的操

malloc動態記憶體分配機制原理_及_linux/proc/介紹

程序系統資源的使用原理          大部分程序通過glibc申請使用記憶體，但是glibc也是一個應用程式庫，它最終也是要呼叫作業系統的記憶體管理介面來使用記憶體。大部分情況下，glibc對使用者和作業系統是透

java中的記憶體分配

2018年11月01日 18:04:01 CrankyST 閱讀數：2 個人分類： java

程式中的記憶體分配

程式的記憶體分配？ 答：一個由c/c++編譯的程式佔用記憶體分為以下幾個部分： 1棧區 由編譯器自動分配釋放，存放函式的引數值，區域性變數的值等，其操作方式類似於資料結構中的棧； 2堆區 一般由程式設計師分配釋放，若程式設計師不釋放，程式結束時可能由OS回收，注

iOS開發中的記憶體分配（堆和棧）

程序的記憶體分割槽 所有程序（執行的程式）都必須佔用一定數量的記憶體，它或是用來存放從磁碟載入的程式程式碼，或是存放取自使用者輸入的資料等等。不過程序對這些記憶體的管理方式因記憶體用途不一而不盡相同，有些記憶體是事先靜態分配和統一回收的，而有些卻是按需要動態分配和回收的

STL中vector以及 for_each幾種用法

/* * vector_test.cpp * * Created on: 2015-3-22 * Author: gino */ #include <iostream> #include <vector> #includ

1063 Set Similarity （25 分）【STL中vector與set的使用】

1063 Set Similarity （25 分） Given two sets of integers, the similarity of the sets is defined to be N​c​​/N​t​​×100%, where N​c​​

STL中vector的建構函式

注意，拷貝有深拷貝和淺拷貝兩種方式。 一般在建立一個新的物件時使用的就是深拷貝，即元素值相同，地址空間不同，而在使用一個vector物件進行值傳遞傳參時，使用的就是淺拷貝，即形參是實參的一份臨時拷貝。這往往是會出問題的，所以建議在使用vector作為引數時，儘量傳引用。

c++ STL容器的記憶體分配

一.前言 在使用STL各類容器的時候，有時會出現迭代器失效，引用(指標)失效等情況的而發生，即使看似你的操作都是合法的情況下。 要了解問題的原因，我們就要了解C++中stl容器的記憶體分配策略。我們才知道在哪些操作下可能導致迭代器失效，引用(指標)失效。

[C++]STL中vector容器 begin()與end()函式、front()與back()的用法

    本部落格轉自http://blog.csdn.net/duan19920101/article/details/51679517 一、begin函式 函式原型: iterator begin(); const_iterator begin(); 功能： 返回一個當

C++STL中vector容器 begin()與end()函式、front()與back()的用法

一、begin函式 函式原型: iterator begin(); const_iterator begin(); 功能： 返回一個當前vector容器中起始元素的迭代器。 二、end函式 函式原型： iterator end(); const_iterator end(