C++的new和delete詳解
1、new和delete的內部實現
C++中如果要在堆內存中創(chuàng)建和銷毀對象需要借助關鍵字new和delete來完成。比如下面的代碼
class CA
{
public:
CA()m_a(0){}
CA(int a):m_a(a){}
virtual void foo(){ cout<<m_a<<endl;}
int m_a;
};
void main()
{
CA *p1 = new CA;
CA *p2 = new CA(10);
CA *p3 = new CA[20];
delete p1;
delete p2;
delete[] p3;
}
new和delete既是C++中的關鍵字也是一種特殊的運算符。
void* operator new(size_t size); void* operator new[](size_t size); void operator delete(void *p); void operator delete[](void *p);
new和delete不僅承載著內存分配的功能還承載著對象構造函數的調用功能，因此上面的對象創(chuàng)建代碼其實在編譯時會轉化為如下的實現：
CA *p1 = operator new(sizeof(CA)); //分配堆內存
CA::CA(p1); //調用構造函數
CA *p2 = operator new(sizeof(CA)); //分配堆內存
CA::CA(p2, 10); //調用構造函數
CA *p3 = operator new[](20 * sizeof(CA));
CA *pt = p3;
for (int i = 0; i < 20; i++)
{
CA::CA(pt);
pt += 1;
}
CA::~CA(p1);
operator delete(p1);
CA::~CA(p2);
operator delete(p2);
CA *pt = p3;
for (int i = 0; i < 20; i++)
{
CA::~CA(pt);
pt += 1;
}
operator delete[](p3);
看到上面的代碼也許你會感到疑惑，怎么在編譯時怎么會在源代碼的基礎上插入這么多的代碼。這也是很多C程序員吐槽C++語言的原因：C++編譯器會偷偷插入很多未知的代碼或者對源代碼進行修改和處理，而這些插入和修改動作對于程序員來說是完全不可知的！ 言歸正傳，我們還能從上面的代碼中看出new和delete操作其實是分別進行了2步操作：1.內存的分配，2.構造函數的調用；3.析構函數的調用，4.內存的銷毀。所以當對象是從堆內存分配時，構造函數執(zhí)前內存就已經完成分配，同樣當析構函數執(zhí)行完成后內存才會被銷毀。 這里面一個有意思的問題就是當我們分配或者銷毀的是數組對象時，系統(tǒng)又是如何知道應該調用多少次構造函數以及調用多少次析構函數的呢？答案就是在內存分配里面。當我們調用operator new[]來分配數組對象時，編譯器時系統(tǒng)內部會增加4或者8字節(jié)的分配空間用來保存所分配的數組對象的數量。當對數組對象調用構造和析構函數時就可以根據這個數量值來進行循環(huán)處理了。因此上面對數組對象的分配和銷毀的真實代碼其實是按如下方式處理的：
// CA *p3 = new CA[20]; 這句代碼在編譯時其實會轉化為如下的代碼片段
unsigned long *p = operator new[](20 * sizeof(CA) + sizeof(unsigned long)); //64位系統(tǒng)多分配8字節(jié)
*p = 20; //這里保存分配的對象的數量。
CA *p3 = (CA*)(p + 1);
CA *pt = p3;
for (int i = 0; i < *p; i++)
{
CA::CA(pt);
pt += 1;
}
// delete[] p3; 這句代碼在編譯時其實會轉化為如下的代碼片段
unsigned long *p = ((unsigned long*)p3) - 1;
CA *pt = p3;
for (int i = 0; i < *p; i++)
{
CA::~CA(pt);
pt += 1;
}
operator delete[](p);
可見C++中為我們隱藏了多少細節(jié)??！既然new和delete操作默認是從堆中進行內存分配，而且new和delete又是一個普通的運算符函數，那么他內部是如何實現呢？其實也很簡單。我們知道C語言中堆內存分配和銷毀的函數是malloc/free。因此C++中對系統(tǒng)默認的new和delete運算符函數就可以按如下的方法實現：
void * operator new(size_t size)
{
return malloc(size);
}
void * operator new[](size_t size)
{
return malloc(size);
}
void operator delete(void *p)
{
free(p);
}
void operator delete[](void *p)
{
free(p);
}
這里需要注意的是你在代碼里面使用new關鍵字和使用operator new操作符所產生的效果是不一樣的。如果你在代碼里面使用的是new關鍵字那么系統(tǒng)內部除了會調用operator new操作符來分配內存還會調用構造函數，而如果你直接使用operator new時則只會進行內存分配而不會執(zhí)行任何構造就比如下面的代碼：
CA *p1 = new CA; //這里會分配內存和執(zhí)行構造函數 CA *p2 = operator new(sizeof(CA)); //這里只是執(zhí)行了普通的堆內存分配而不會調用構造函數
上述的偽代碼都是在運行時通過查看匯編語言而得出的結論,我是在XCODE編譯器上查看運行的結果，有可能不同的編譯器會有一些實現的差異，但是不管如何要想真實的了解內部實現原理還是要懂一些匯編的知識為最好。
2、placement技術
系統(tǒng)默認的new關鍵字除了分配堆內存外還進行構造函數的調用。而實際中我們可能有一些已經預先分配好的內存區(qū)域，我們想在這些已經分配好的內存中來構建一個對象。還有一種情況是不希望進行頻繁的堆內存分配和釋放而只是對同一塊內存進行重復的對象構建和銷毀。就如下面的代碼：
char buf1[100]; CA *p1 = (CA*)buf1; CA::CA(p1); p1->foo(); p1->m_a = 10; char *buf2 = new char[sizeof(CA)]; CA *p2 = (CA*)buf2; CA::CA(p2); p2->foo(); p2->m_a = 20; p1->~CA(); p2->~CA(); delete[] buf2;
可以看出代碼中buf1是棧內存而buf2是堆內存，這兩塊內存區(qū)域都是已經分配好了的內存，現在我們想把這些內存來當做CA類的對象來使用，因此我們需要對內存調用類的構造函數CA::CA()才可以，構造函數的內部實現會為內存區(qū)域填充虛表指針，這樣對象才可以調用諸如foo虛函數。但是這樣寫代碼不夠優(yōu)雅，那么有沒有比較優(yōu)雅的方法來實現在一塊已經存在的內存上來構建對象呢？ 答案就是 placement技術。 C++中的仍然是使用new和delete來實現這種技術。new和delete除了實現默認的操作符外還重載實現了如下的操作符函數：
void* operator new(size_t size, void *p)
{
return p;
}
void* operator new[](size_t size, void *p)
{
return p;
}
void operator delete(void *p1, void *p2)
{
// do nothing..
}
void operator delete[](void *p1, void *p2)
{
// do nothing..
}
我們稱這四個運算符為 placement new 和 placement delete 。通過這幾個運算符我們就可以優(yōu)雅的實現上述的功能：
char buf1[100]; CA *p1 = new(buf1) CA(10); //調用 operator new(size_t, void*) p1->foo(); char *buf2 = new char[sizeof(CA)]; CA *p2 = new(buf2) CA(20); //調用 operator new(size_t, void*) p2->foo(); p1->~CA(); operator delete(p1, buf1); //調用 operator delete(void*, void*) p2->~CA(); operator delete(p2, buf2); //調用 operator delete(void*, void*) delete[] buf2;
上面的例子里面發(fā)現通過placement new可以很優(yōu)雅的在現有的內存中構建對象，而析構時不能直接調用delete p1, delete p2來銷毀對象，必須人為的調用析構函數以及placement delete 函數。并且從上面的placement delete的實現來看里面并沒有任何代碼，既然如此為什么還要定義一個placement delete呢？ 答案就是C++中的規(guī)定對new和delete的運算符重載必須是要成對實現的。而且前面曾經說過對delete的使用如果帶了operator前綴時就只是一個普通的函數調用。因此為了完成析構以及和new操作符的匹配，就必須要人為的調用對象的析構函數以及placement delete函數。 除了上面舉的例子外placement技術的使用還可以減少內存的頻繁分配以及提升系統(tǒng)的性能。
void main()
{
for (int i = 0; i < 10000; i++)
{
CA *p = new CA(i);
p->foo();
delete p;
}
}
例子里面循環(huán)10000次，每次循環(huán)都創(chuàng)建一個堆內存對象，然后調用虛函數foo后再進行銷毀。最終的結果是程序運行時會進行10000次的頻繁的堆內存分配和銷毀。很明顯這是有可能會影響系統(tǒng)性能的而且還有可能發(fā)生堆內存分配失敗的情況。而如果我們借助placement 技術就可以很簡單的解決這些問題。
void main()
{
char *buf = new[](sizeof(CA));
for (int i = 0; i < 10000; i++)
{
CA *p = new(buf) CA(i);
p->foo();
p->~CA();
operator delete(p, buf);
}
delete[] buf;
}
上面的例子里面只進行了一次堆內存分配，在循環(huán)里面都是借助已經存在的內存來構建對象，不會再分配內存了。這樣對內存的重復利用就使得程序的性能得到非常大的提升。
3、new和delete運算符重載
發(fā)現一個很有意思的事情就是越高級的語言就越會將一些系統(tǒng)底層的東西進行封裝并形成一個語言級別的關鍵字來使用。比如C++中的new和delete是用于構建和釋放堆內存對象的關鍵字，又比如go語言中chan關鍵字是用于進行同步或者異步的隊列數據傳輸通道。 C++語言內置默認實現了一套全局new和delete的運算符函數以及placement new/delete運算符函數。不管是類還是內置類型都可以通過new/delete來進行堆內存對象的分配和釋放的。對于一個類來說，當我們使用new來進行構建對象時，首先會檢查這個類是否重載了new運算符，如果這個類重載了new運算符那么就會調用類提供的new運算符來進行內存分配，而如果沒有提供new運算符時就使用系統(tǒng)提供的全局new運算符來進行內存分配。內置類型則總是使用系統(tǒng)提供的全局new運算符來進行內存的分配。對象的內存銷毀流程也是和分配一致的。 new和delete運算符既支持全局的重載又支持類級別的函數重載。下面是這種運算符的定義的格式：
//全局運算符定義格式
void * operator new(size_t size [, param1, param2,....]);
void operator delete(void *p [, param1, param2, ...]);
//類內運算符定義格式
class CA
{
void * operator new(size_t size [, param1, param2,....]);
void operator delete(void *p [, param1, param2, ...]);
};
對于new/delete運算符重載我們總有如何下規(guī)則：
new和delete運算符重載必須成對出現- new運算符的第一個參數必須是size_t類型的，也就是指定分配內存的size尺寸；
delete運算符的第一個參數必須是要銷毀釋放的內存對象。其他參數可以任意定義。 - 系統(tǒng)默認實現了
new/delete、new[]/delete[]、placement new / delete6個運算符函數。它們都有特定的意義。 - 你可以重寫默認實現的全局運算符，比如你想對內存的分配策略進行自定義管理或者你想監(jiān)測堆內存的分配情況或者你想做堆內存的內存泄露監(jiān)控等。但是你重寫的全局運算符一定要滿足默認的規(guī)則定義。
- 如果你想對某個類的堆內存分配的對象做特殊處理，那么你可以重載這個類的
new/delete運算符。當重載這兩個運算符時雖然沒有帶static屬性，但是不管如何對類的new/delete運算符的重載總是被認為是靜態(tài)成員函數。 - 當
delete運算符的參數>=2個時，就需要自己負責對象析構函數的調用，并且以運算符函數的形式來調用delete運算符。
一般情況下你不需要對new/delete運算符進行重載，除非你的整個應用或者某個類有特殊的需求時才會如此。下面的例子你可以看到我的各種運算符的重載方法以及使用方法：
//CA.h
class CA
{
public:
//類成員函數
void * operator new(size_t size);
void * operator new[](size_t size);
void * operator new(size_t size, void *p);
void * operator new(size_t size, int a, int b);
void operator delete(void *p);
void operator delete[](void *p);
void operator delete(void *p, void *p1);
void operator delete(void *p, int a, int b);
};
class CB
{
public:
CB(){}
};
//全局運算符函數，請謹慎重寫覆蓋全局運算符函數。
void * operator new(size_t size);
void * operator new[](size_t size);
void * operator new(size_t size, void *p) noexcept;
void * operator new(size_t size, int a, int b);
void operator delete(void *p);
void operator delete[](void *p);
void operator delete(void *p, void *p1);
void operator delete(void *p, int a, int b);
.......................................................
//CA.cpp
void * CA::operator new(size_t size)
{
return malloc(size);
}
void * CA::operator new[](size_t size)
{
return malloc(size);
}
void * CA::operator new(size_t size, void *p)
{
return p;
}
void* CA::operator new(size_t size, int a, int b)
{
return malloc(size);
}
void CA::operator delete(void *p)
{
free(p);
}
void CA::operator delete[](void *p)
{
free(p);
}
void CA::operator delete(void *p, void *p1)
{
}
void CA::operator delete(void *p, int a, int b)
{
free(p);
}
void * operator new(size_t size)
{
return malloc(size);
}
void * operator new[](size_t size)
{
return malloc(size);
}
void * operator new(size_t size, void *p) noexcept
{
return p;
}
void* operator new(size_t size, int a, int b)
{
return malloc(size);
}
void operator delete(void *p)
{
free(p);
}
void operator delete[](void *p)
{
free(p);
}
void operator delete(void *p, void *p1)
{
}
void operator delete(void *p, int a, int b)
{
free(p);
}
..................................
//main.cpp
int main(int argc, const char * argv[]) {
char buf[100];
CA *a1 = new CA(); //調用void * CA::operator new(size_t size)
CA *a2 = new CA[10]; //調用void * CA::operator new[](size_t size)
CA *a3 = new(buf)CA(); //調用void * CA::operator new(size_t size, void *p)
CA *a4 = new(10, 20)CA(); //調用void* CA::operator new(size_t size, int a, int b)
delete a1; //調用void CA::operator delete(void *p)
delete[] a2; //調用void CA::operator delete[](void *p)
//a3用的是placement new的方式分配，因此需要自己調用對象的析構函數。
a3->~CA();
CA::operator delete(a3, buf); //調用void CA::operator delete(void *p, void *p1)，記得要帶上類命名空間。
//a4的運算符參數大于等于2個所以需要自己調用對象的析構函數。
a4->~CA();
CA::operator delete(a4, 10, 20); //調用void CA::operator delete(void *p, int a, int b)
//CB類沒有重載運算符，因此使用的是全局重載的運算符。
CB *b1 = new CB(); //調用void * operator new(size_t size)
CB *b2 = new CB[10]; //調用void * operator new[](size_t size)
//這里你可以看到同一塊內存可以用來構建CA類的對象也可以用來構建CB類的對象
CB *b3 = new(buf)CB(); //調用void * operator new(size_t size, void *p)
CB *b4 = new(10, 20)CB(); //調用void* operator new(size_t size, int a, int b)
delete b1; //調用void operator delete(void *p)
delete[] b2; //調用void operator delete[](void *p)
//b3用的是placement new的方式分配，因此需要自己調用對象的析構函數。
b3->~CB();
::operator delete(b3, buf); //調用void operator delete(void *p, void *p1)
//b4的運算符參數大于等于2個所以需要自己調用對象的析構函數。
b4->~CB();
::operator delete(b4, 10, 20); //調用void operator delete(void *p, int a, int b)
return 0;
}
我是在XCODE上測試上面的代碼的，因為重寫了全局的new/delete運算符，并且內部是通過malloc來實現堆內存分配的， malloc函數申明了不能返回NULL的返回結果檢測: void *malloc(size_t __size) __result_use_check __alloc_size(1) ; 因此有可能你在測試時會發(fā)生崩潰的問題。如果出現這個問題你可以嘗試著注釋掉對全局new/delete重寫的代碼，再運行查看結果。 可見如果你嘗試著覆蓋重寫全局的new/delete時是有可能產生風險的。
4、對象的自動刪除技術
一般來說系統(tǒng)對new/delete的默認實現就能滿足我們的需求，我們不需要再去重載這兩個運算符。那為什么C++還提供對這兩個運算符的重載支持呢？答案還是在運算符本身具有的缺陷所致。我們知道用new關鍵字來創(chuàng)建堆內存對象是分為了2步：1.是堆內存分配，2.是對象構造函數的調用。而這兩步中的任何一步都有可能會產生異常。如果說是在第一步出現了問題導致內存分配失敗則不會調用構造函數，這是沒有問題的。如果說是在第二步構造函數執(zhí)行過程中出現了異常而導致無法正常構造完成，那么就應該要將第一步中所分配的堆內存進行銷毀。C++中規(guī)定如果一個對象無法完全構造那么這個對象將是一個無效對象，也不會調用析構函數。為了保證對象的完整性，當通過new分配的堆內存對象在構造函數執(zhí)行過程中出現異常時就會停止構造函數的執(zhí)行并且自動調用對應的delete運算符來對已經分配的堆內存執(zhí)行銷毀處理，這就是所謂的對象的自動刪除技術。正是因為有了對象的自動刪除技術才能解決對象構造不完整時會造成內存泄露的問題。
當對象構造過程中拋出異常時，C++的異常處理機制會在特定的地方插入代碼來實現對對象的delete運算符的調用，如果想要具體了解情況請參考C++對異常處理實現的相關知識點。
全局delete運算符函數所支持的對象的自動刪除技術雖然能解決對象本身的內存泄露問題，但是卻不能解決對象構造函數內部的數據成員的內存分配泄露問題，我們來看下面的代碼：
class CA
{
public:
CA()
{
m_pa = new int;
throw 1;
}
~CA()
{
delete m_pa;
m_pa = NULL;
}
private:
int *m_pa;
};
void main()
{
try
{
CA *p = new CA();
delete p; //這句代碼永遠不會執(zhí)行
}
catch(int)
{
cout << "oops!" << endl;
}
}
上面的代碼中可以看到類CA中的對象在構造函數內部拋出了異常，雖然系統(tǒng)會對p對象執(zhí)行自動刪除技術來銷毀分配好的內存，但是對于其內部的數據成員m_pa來說，因為構造不完整就不會調用析構函數來銷毀分配的堆內存，這樣就導致了m_pa這塊內存出現了泄露。怎么解決這類問題呢？ 答案你是否想到了？ 那就是重載CA類的new/delete運算符。我們來看通過對CA重載運算符解決問題的代碼：
class CA
{
public:
CA(){
m_pa = new int;
throw 1;
}
//因為對象構造未完成所以析構函數永遠不會被調用
~CA()
{
delete m_pa;
m_pa = NULL;
}
void * operator new(size_t size)
{
return malloc(size);
}
//重載delete運算符，把已經分配的內存銷毀掉。
void operator delete(void *p)
{
CA *pb = (CA*)p;
if (pb->m_pa != NULL)
delete pb->m_pa;
free(p);
}
private:
int *m_pa;
};
因為C++對自動刪除技術的支持，當CA對象在構造過程中發(fā)生異常時，我們就可以通過重載delete運算符來解決那些在構造函數中分配的數據成員內存但又不會調用析構函數來銷毀的數據成員的內存問題。這我想就是為什么C++中要支持對new/delete運算符在類中重載的原因吧。
到此這篇關于C++的new和delete詳解的文章就介紹到這了,更多相關C++的new和delete內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要為大家詳細介紹了C語言數組應用實現掃雷游戲，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-06-06
所謂幀差法也就是對連續(xù)圖像幀做差分運算，其結果與定義好的閾值比較，若大于閾值則為運動目標值為1，否則值為0?。本文將利用幀差法實現車輛識別，感興趣的可以了解一下2022-08-08
本文主要介紹了C語言中#define到底存在程序的哪個區(qū),以及工作流程和效率與普通函數的區(qū)別,希望能幫助需要的小伙伴2016-07-07
這篇文章主要給大家介紹了關于C語言中結構體、枚舉、聯合體和位段自定義類型的相關資料,分別介紹了結構體、枚舉、聯合體和位段等四種自定義類型,文中通過示例代碼介紹的非常詳細,需要的朋友可以參考下2021-08-08
此處對于指針做一些簡要的介紹，作者實屬初學，寫博客也是作者學習的一個過程，難免文章中有內容理解不到位或者有不當之處，還請朋友們不吝指正，希望大家給予支持2021-11-11
這篇文章主要為大家詳細介紹了如何利用Matlab實現甘特圖(gantt?chart)的繪制，文中的示例代碼講解詳細，對我們學習Matlab有一定幫助，需要的可以參考一下2022-10-10
在c/c++中，為了解決一些頻繁調用的小函數大量消耗?？臻g（棧內存）的問題，特別的引入了inline修飾符，表示為內聯函數。 棧空間就是指放置程序的局部數據（也就是函數內數據）的內存空間2017-09-09
這篇文章主要給大家介紹了C++實現日期類的方法,文中通過代碼示例給大家介紹的非常詳細,對大家的學習或工作有一定的幫助,需要的朋友可以參考下2024-01-01
這篇文章主要為大家詳細介紹了C語言實現點菜系統(tǒng)，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-06-06
不知道你是否和我一樣好奇，學習編程語言的同時想，各個數據類型是怎樣在我們的內存中儲存的呢，如果你仔細深入了解的話，你會了解其中的樂趣，了解科學家們的偉大，了解c語言2022-02-02