C++入門之內存處理詳解

Posted on by

前言

兜兜轉轉,我們終於結束瞭C++中非常重要的一環**(類和對象),現在來到瞭C++中的內存管理章節.在此篇文章中,博主將會介紹內存的分佈,不同於c的新型申請堆區空間方法,new,delete和C中的malloc等有什麼不同.**

C/C++內存分佈

在c和c++中,內存區大概分為這幾個板塊:棧區,內存映射段,堆區,數據段和代碼段.

  • 棧區: 存放非靜態局部變量,函數參數,函數返回值等,其優先使用高地址,並逐漸往下.
  • 內存映射段:高效的I/O映射方式，用於裝載一個共享的動態內存庫。用戶可使用系統接口創建共享內存，做進程間通信.由於博主還未更新到操作系統,這裡不做過多介紹.
  • 堆區: 用於程序運行時進行動態內存分配(一般使用malloc),其優先使用低地址,逐漸往上.
  • 數據段:存儲全局數據和靜態變量.
  • 代碼段:可執行的代碼/隻讀常量.

理論千遍,不如用例子一現,大傢往下看:

image-20211024195521282

在上圖中,大傢可以清晰的看到各種類型數據的存儲區域,一目瞭然.

c語言中動態內存管理方式

我們在學習c語言時候,想要向堆區申請一塊空間,隻能通過malloc()函數,而且操作比較麻煩,需要計算申請空間的大小並且進行強制轉換.

int* p1 = (int*) malloc(sizeof(int));
free(p1);
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
free(p3 );

我們可以清晰的看到,在c語言中申請一塊堆區內存空間,操作有點繁瑣,那麼在C++語言中,是怎麼申請一塊堆區內存呢?

C++內存管理方式

在c++中,c語言的內存管理方式依然可以使用,但是有些地方仍然使用c中的方法進行申請就比較麻煩,因此C++又提出瞭自己的內存管理方式:通過new和delete操作符進行動態內存管理.

那麼什麼時候使用c內存管理方式就會比較麻煩呢?比如下面:

class Stack
{
public:
	Stack(int* p,int n)
    {
        val = p;
        top = capacity = n;
    }
private:
    int* val;
    int top;
    int capacity;
};
int main()
{
    Stack* stack = (Stack*)malloc(sizeof(Stack));
    //然後現在我們想要進行初始化,發現好像不能操作瞭(因為私有成員外部無法訪問),這就會比較麻煩,因此提出瞭new和delete的操作
    return 0;
}

new和delete操作基礎類型

①開辟單個元素基本語法: type* name = new type(content);

①釋放空間語法: delete name;

其中type是開辟的元素類型,name是變量名,content是想要賦的值,例如:

int* a = new int(10);         //開辟一個整型空間,並且初始化為10;
char* s = new char('s');      //開辟一個字符空間,並且初始化為's';
delete a;
delete s;                     //釋放a和s

②開辟數組基本語法: type* name = new type[n]

②刪除數組基本語法:delete[] name;

其中type是開辟的元素類型,name是數組名,n是空間數量,例如:

int* num = new int[10];         //開辟10個int類型的空間
char* str = new char[10];        //開辟10個char類型的空間
delete[] num;
delete[] str;    //釋放num和str;

註意點:在c語言中malloc,realloc,calloc等是函數,在c++中,new和delete是操作符.

new和delete操作自定義類型

使用語法和上面的自定義類型幾乎一樣,隻是初始化位置有點差別,語法:type* name = new type(s1,s2,s3...);

其中type是自定義的類型,s1,s2,s3等是自定義類型中構造函數的對應參數.例子:

class Test
{
public:
    Test(int a,int b,int c)
    {
        _a = a;
        _b = b;
        _c = c;
    }
private:
    int _a;
    int _b;
    int _c;
};
int main()
{
    Test* t = new Test(1,2,3);  //根據構造函數參數列表寫對應參數.
    delete t;
}

基於malloc開辟並初始化的自定義類型

有人可能會有點好奇,說,我就是要用malloc開辟自定義類型,但是我還想初始化,這麼進行操作?答案是,可以的,需要搭配new

語法 new(type*) type(s1,s2,s3...)

什麼意思呢?我們仍然按照上面的Test類舉例:

Test* t = (Test*) malloc(sizeof(Test));
new(t)Test(1,2,3);    //這樣就可以初始化瞭.

new和delete底層實現原理

在講解他們的底層實現原理之前我們先介紹一下兩個全局函數,分別是operator new 和operator delete.

operator new和operator delete

大傢看到上面的形式可能會誤認為是對new和delete進行瞭重載,實際並不是,隻是這兩個函數就叫做這名字而已.

我們在學習C語言時候,還記得是當開辟空間時候需要進行檢查是否成功嗎?而operator new其實和malloc一模一樣,隻是它對空間開辟失敗後做出的反應是拋出異常,而c語言中,我們是手動判斷,然後停止.下面是operator new的代碼:

void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
	// try to allocate size bytes
	void* p;
	while ((p = malloc(size)) == 0)              //如果開辟成功就不會進入循環,並且可以清晰
		if (_callnewh(size) == 0)
		{
			// report no memory
			// 如果申請內存失敗瞭，這裡會拋出bad_alloc 類型異常
			static const std::bad_alloc nomem;
			_RAISE(nomem);
		}
	return (p);
}

同理,operator delete不過也就是free,下面是它的代碼:

void operator delete(void* pUserData)
{
	_CrtMemBlockHeader* pHead;
	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
	if (pUserData == NULL)
		return;
	_mlock(_HEAP_LOCK); /* block other threads */
	__TRY
		/* get a pointer to memory block header */
		pHead = pHdr(pUserData);
	/* verify block type */
	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
	_free_dbg(pUserData, pHead->nBlockUse);
	__FINALLY
		_munlock(_HEAP_LOCK); /* release other threads */
	__END_TRY_FINALLY
		return;
}

總結:operator new其實就是對malloc的封裝,operator delete 就是堆free的封裝.

new的底層實現

new的實現其實是進一步對malloc的封裝,因為new的操作可以分為下面兩件事:

  • 調用operator new進行開辟空間.
  • 如果開辟的空間是自定義類型,new再調用其構造函數.

所以說,new的內部其實就是有構造函數和operator new封裝而成.

delete的底層實現

同樣的道理,delete不過就是對free的進一步封裝,因為delete的操作可以分為下面兩件事:

  • 如果new開辟的空間是自定義類型,則首先調用其析構函數釋放其內部資源.
  • 然後再調用operator delete,進行釋放new所開辟出來的空間.

註意瞭,這裡可能有人不明白自定義類型先釋放內部,然後銷毀外部空間啥意思,博主這裡畫圖介紹,不過大傢先看一下下面的一個類:

class Stack
{
public:
	Stack()
		:num(new int[10]),
		top(0),capacity(10)
	{}
	~Stack()
	{
		delete[] num;
		top = capacity = 0;
	}
private:
	int* num;
	int top;
	int capacity;
};
int main()
{
    Stack stack;
    delete stack;
    return 0;
}

如果我們定義一個該對象,那麼其空間分佈如下:

image-20211025172631194

如果delete不先調用析構函數,那麼釋放瞭stack對象後,在堆區裡面的num將會繼續存在,導致內存泄露.

new[]的底層實現

1.調用operator new[]函數，在operator new[]中實際調用operator new函數完成N個對象空間的申請

2.在申請的空間上執行N次構造函數

delete[]的原理

1.在釋放的對象空間上執行N次析構函數，完成N個對象中資源的清理

2.調用operator delete[]釋放空間，實際在operator delete[]中調用operator delete來釋放空間

總結

本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容!

推薦閱讀：