C++動態記憶體管理與源碼剖析

• 2021 年 8 月 6 日
• 筆記
• C++, C++記憶體管理

引言

在本篇文章中，我們主要剖析c++中的動態記憶體管理，包括malloc、new expression、operator new、array new和allocator記憶體分配方法以及對應的記憶體釋放方式和他們之間的調用關係，另外也包括一些會引發的陷阱如記憶體泄漏。

動態記憶體管理函數及其調用關係

c++中的動態記憶體分配和釋放方式有很多，主要包括：

• malloc與free
• new expression與delete expression
• array new 與array delete
• operator new和operator delete
• allocator中的allocate與deallocate

除此之外還有placement new，但需要注意placement new不是用來記憶體分配和釋放的，而是在已分配的記憶體上構造對象。

他們之間的調用關係如下：

下面我們來具體看下每一種分配和釋放方式的使用和原理。

malloc與free

	void *p1 = malloc(32); //分配32位元組的記憶體
	free(p1);//釋放指針p1指向的記憶體

malloc函數以位元組數為參數，返回指向分配的記憶體的首地址的void指針；而free函數釋放給定指針指向的記憶體。

operator new與operator delete

	void *p6 = ::operator new(32); //分配32位元組
	::operator delete(p6);

PS：底層調用malloc和free。gnu的實現：

_GLIBCXX_WEAK_DEFINITION void *
operator new (std::size_t sz) _GLIBCXX_THROW (std::bad_alloc)
{
  void *p;

  /* malloc (0) is unpredictable; avoid it.  */
  if (__builtin_expect (sz == 0, false))
    sz = 1;

  while ((p = malloc (sz)) == 0)
    {
      new_handler handler = std::get_new_handler ();
      if (! handler)
	_GLIBCXX_THROW_OR_ABORT(bad_alloc());
      handler ();
    }

  return p;
}

_GLIBCXX_WEAK_DEFINITION void
operator delete(void* ptr) noexcept
{
  std::free(ptr);
}

new expression與delete expression

首先來看下簡單的使用：

	int *p2 = new int;
	delete p2;
	
	string *p3 = new string("hello");
	delete p3;

new expression完成兩樣工作：

1. 申請並分配記憶體。

2. 調用構造函數。

string *p3 = new string("hello");被編譯器替換成下面的工作：

	string *p3;
	try{
            void * tmp_p = operator new(sizeof(string));
            p3 = static_cast<string *>(tmp_p);
            //string 通過宏被替換為basic_string，string的實際實現是basic_string，這裡不是重點。
            p3 -> basic_string::basic_string("hello");	//編譯器可以這麼調用，但我們自己寫程式碼時不能。即我們不能以這種方式通過指針顯式調用構造函數。
        }catch (std::bad_alloc){
            //若分配失敗，構造函數不執行
        }

我們看到，原來new expression的記憶體申請和分配是通過調用operator new()來完成的。

delete expression也完成兩樣工作：

1. 調用析構函數。
2. 釋放記憶體。

delete p3;被編譯器替換成下面的工作：

	p3 -> ~string();//通過指針直接調用析構函數。我們自己寫程式碼時也可以這麼做。
	operator delete(p3);//釋放記憶體

array new 與array delete

	//Complex為自定義類，只需要知道Complex類中沒有指針成員。
	Complex *pca = new Complex[3];//3次構造函數
	delete[] pca;//3次析構函數

	string *psa = new string[3];//3次構造函數
	delete[] psa;//3次析構函數

array new調用一次記憶體分配函數（底層源碼實現中，其實是調用operator new，只是調用的時候計算好了大小。因此，有上下兩個cookie。）和多次構造函數。正因為調用多次構造函數，因此只能調用無參構造函數。

Complex和string的很大不同之處在於，string有指針成員，布局如下圖：

array delete調用多次析構函數，一次記憶體釋放函數（底層源碼實現中其實是調用一次operator delete）。

我們來看下，如果本應該使用array delete的地方使用了delete expression會發生什麼：

	Complex *pca = new Complex[3];//3次構造函數
	delete pca;//1次析構函數

	string *psa = new string[3];//3次析構函數
	delete psa;//1次析構函數

對於Complex，我們使用了array new調用了3次構造函數，卻沒有使用array delete而使用了delete expression，因此只調用了一次析構函數。那麼，會發生記憶體泄漏嗎？ 不會。因為Complex的析構函數是無關痛癢的(trivial)，因為沒有要釋放的關聯的記憶體（Complex對象自身所佔記憶體之外沒有隱式佔用的記憶體）。

同樣，對於string，我們使用了array new調用了3次構造函數，卻沒有使用array delete而使用了delete expression，因此只調用了一次析構函數。那麼，會發生記憶體泄漏嗎？ 會。因為string的析構函數不是無關痛癢的(non-trivial)，因為要釋放關聯的記憶體（我們知道string底層是通過char[]存儲的，析構時會釋放掉那些實際存儲字元的記憶體）。

PS: 具體的記憶體布局例子（涉及到cookie、對齊填充padding等等）。

	int *p = new int[10];
	delete[]p;
	//delete p 亦可。int無關痛癢。

VC6中的記憶體布局如下：

另：

	Demo *p = new Demo[3];//Demo為析構函數non-trivial的自定義class
	delete[] p;
	//delete p; //錯誤

VC6中的記憶體布局（注意紅框內的3）：

allocate與deallocate

#ifdef __GNUC__	//GNUC環境下
	void *p7 = allocator<int>().allocate(4);  //非static函數，通過實例化匿名對象調用allocate，分配4個int的記憶體。
	allocator<int>().deallocate((int *)p7, 4);
	
	void *p8 = __gnu_cxx::__pool_alloc<int>().allocate(4);
	__gnu_cxx::__pool_alloc<int>().deallocate((int *)p8, 4);
#endif

allocator為模板，實例化時需提供模板類型參數，上面的程式中模板類型參數為<int>，allocate的參數為4則allocate函數分配時就分配4個int的記憶體。釋放記憶體時需要給出指向所要釋放的記憶體位置的指針，以及要釋放的記憶體大小，單位為模板類型參數類型的大小。

__pool_alloc也為模板，除底層調用malloc的時機不同外（__pool_alloc使用記憶體池降低cookie帶來的overhead），使用和上面的allocator相同。

placement new

用法：

	char *buf = new char[sizeof(Complex) * 3];
	Complex *pc = new(buf) Complex(1, 2);
	new(buf + 1) Complex(1, 3);
	new(buf + 2) Complex(1, 3);
	delete[] buf;

Complex *pc = new(buf) Complex(1, 2);被編譯器替換成如下的工作：

	Complex *pc;
	try{
            void *tmp = operator new(sizeof(Complex), buf);//該重載版本並不分配記憶體。buf指針已經指向記憶體。
            pc = static_cast<Complex*>(tmp);
            pc->Complex::Complex(1, 2);//構造函數
        }catch(std::bad_alloc){
            //若分配失敗則不執行構造函數。實際上沒有分配，因為之前已經分配完。
        }

上面使用的GNU庫重載版本的operator new()函數如下:

// Default placement versions of operator new.
_GLIBCXX_NODISCARD inline void* operator new(std::size_t, void* __p) _GLIBCXX_USE_NOEXCEPT
{ return __p; }

可以看到確實沒有分配記憶體。

重載記憶體管理函數

new expression、delete expression都不可重載。

operator new、operator delete可以重載：

• 重載globaloperator new、operator delete，即::operator new(size_t)與::operator delete(void *)。（一般不會重載全局的該函數，因為影響太廣）
• 重載某個class的operator new、operator delete

若某個類重載了operator new、operator delete，則用new expression實例化該類時，調用的是類的operator new、operator delete，否則，調用globaloperator new、operator delete。

array new、array delete也可以重載。同樣分全局的和類所屬的。

具體如何重載這些記憶體管理函數，以及如何使用重載的記憶體管理函數，將在下一篇文章中分析。

參考資料

[1] 《STL源碼剖析》

[2] 《Effective C++》3/e

[3] 《C++ Primer》5/e

[4] 侯捷老師的課程

[5] gcc開源庫：//github.com/gcc-mirror/gcc