欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

深入淺析C++的new和delete

 更新時(shí)間:2018年02月26日 11:10:03   作者:歐陽大哥  
new和delete既是C++中的關(guān)鍵字也是一種特殊的運(yùn)算符。這篇文章主要介紹了C++的new和delete詳解,需要的朋友可以參考下

new和delete的內(nèi)部實(shí)現(xiàn)

C++中如果要在堆內(nèi)存中創(chuàng)建和銷毀對象需要借助關(guān)鍵字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++中的關(guān)鍵字也是一種特殊的運(yùn)算符。

void* operator new(size_t size);
 void* operator new[](size_t size);
 void operator delete(void *p);
 void operator delete[](void *p);

new和delete不僅承載著內(nèi)存分配的功能還承載著對象構(gòu)造函數(shù)的調(diào)用功能,因此上面的對象創(chuàng)建代碼其實(shí)在編譯時(shí)會(huì)轉(zhuǎn)化為如下的實(shí)現(xiàn):    

CA *p1 = operator new(sizeof(CA)); //分配堆內(nèi)存
  CA::CA(p1); //調(diào)用構(gòu)造函數(shù)
  CA *p2 = operator new(sizeof(CA)); //分配堆內(nèi)存
  CA::CA(p2, 10); //調(diào)用構(gòu)造函數(shù)
  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);

看到上面的代碼也許你會(huì)感到疑惑,怎么在編譯時(shí)怎么會(huì)在源代碼的基礎(chǔ)上插入這么多的代碼。這也是很多C程序員吐槽C++語言的原因:C++編譯器會(huì)偷偷插入很多未知的代碼或者對源代碼進(jìn)行修改和處理,而這些插入和修改動(dòng)作對于程序員來說是完全不可知的!

言歸正傳,我們還能從上面的代碼中看出new和delete操作其實(shí)是分別進(jìn)行了2步操作:1.內(nèi)存的分配,2.構(gòu)造函數(shù)的調(diào)用;3.析構(gòu)函數(shù)的調(diào)用,4.內(nèi)存的銷毀。所以當(dāng)對象是從堆內(nèi)存分配時(shí),構(gòu)造函數(shù)執(zhí)前內(nèi)存就已經(jīng)完成分配,同樣當(dāng)析構(gòu)函數(shù)執(zhí)行完成后內(nèi)存才會(huì)被銷毀。

這里面一個(gè)有意思的問題就是當(dāng)我們分配或者銷毀的是數(shù)組對象時(shí),系統(tǒng)又是如何知道應(yīng)該調(diào)用多少次構(gòu)造函數(shù)以及調(diào)用多少次析構(gòu)函數(shù)的呢?答案就是在內(nèi)存分配里面。當(dāng)我們調(diào)用operator new[]來分配數(shù)組對象時(shí),編譯器時(shí)系統(tǒng)內(nèi)部會(huì)增加4或者8字節(jié)的分配空間用來保存所分配的數(shù)組對象的數(shù)量。當(dāng)對數(shù)組對象調(diào)用構(gòu)造和析構(gòu)函數(shù)時(shí)就可以根據(jù)這個(gè)數(shù)量值來進(jìn)行循環(huán)處理了。因此上面對數(shù)組對象的分配和銷毀的真實(shí)代碼其實(shí)是按如下方式處理的:

 // CA *p3 = new CA[20]; 這句代碼在編譯時(shí)其實(shí)會(huì)轉(zhuǎn)化為如下的代碼片段
  unsigned long *p = operator new[](20 * sizeof(CA) + sizeof(unsigned long)); //64位系統(tǒng)多分配8字節(jié)
  *p = 20; //這里保存分配的對象的數(shù)量。
  CA *p3 = (CA*)(p + 1);
  CA *pt = p3;
  for (int i = 0; i < *p; i++)
  {
   CA::CA(pt);
   pt += 1;
  }
 // delete[] p3; 這句代碼在編譯時(shí)其實(shí)會(huì)轉(zhuǎn)化為如下的代碼片段
  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++中為我們隱藏了多少細(xì)節(jié)?。〖热籲ew和delete操作默認(rèn)是從堆中進(jìn)行內(nèi)存分配,而且new和delete又是一個(gè)普通的運(yùn)算符函數(shù),那么他內(nèi)部是如何實(shí)現(xiàn)呢?其實(shí)也很簡單。我們知道C語言中堆內(nèi)存分配和銷毀的函數(shù)是malloc/free。因此C++中對系統(tǒng)默認(rèn)的new和delete運(yùn)算符函數(shù)就可以按如下的方法實(shí)現(xiàn):

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關(guān)鍵字和使用operator new操作符所產(chǎn)生的效果是不一樣的。如果你在代碼里面使用的是new關(guān)鍵字那么系統(tǒng)內(nèi)部除了會(huì)調(diào)用operator new操作符來分配內(nèi)存還會(huì)調(diào)用構(gòu)造函數(shù),而如果你直接使用operator new時(shí)則只會(huì)進(jìn)行內(nèi)存分配而不會(huì)執(zhí)行任何構(gòu)造就比如下面的代碼: 

 CA *p1 = new CA; //這里會(huì)分配內(nèi)存和執(zhí)行構(gòu)造函數(shù)
 CA *p2 = operator new(sizeof(CA)); //這里只是執(zhí)行了普通的堆內(nèi)存分配而不會(huì)調(diào)用構(gòu)造函數(shù)

上述的偽代碼都是在運(yùn)行時(shí)通過查看匯編語言而得出的結(jié)論,我是在XCODE編譯器上查看運(yùn)行的結(jié)果,有可能不同的編譯器會(huì)有一些實(shí)現(xiàn)的差異,但是不管如何要想真實(shí)的了解內(nèi)部實(shí)現(xiàn)原理還是要懂一些匯編的知識(shí)為最好。

placement技術(shù)

系統(tǒng)默認(rèn)的new關(guān)鍵字除了分配堆內(nèi)存外還進(jìn)行構(gòu)造函數(shù)的調(diào)用。而實(shí)際中我們可能有一些已經(jīng)預(yù)先分配好的內(nèi)存區(qū)域,我們想在這些已經(jīng)分配好的內(nèi)存中來構(gòu)建一個(gè)對象。還有一種情況是不希望進(jìn)行頻繁的堆內(nèi)存分配和釋放而只是對同一塊內(nèi)存進(jìn)行重復(fù)的對象構(gòu)建和銷毀。就如下面的代碼:

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是棧內(nèi)存而buf2是堆內(nèi)存,這兩塊內(nèi)存區(qū)域都是已經(jīng)分配好了的內(nèi)存,現(xiàn)在我們想把這些內(nèi)存來當(dāng)做CA類的對象來使用,因此我們需要對內(nèi)存調(diào)用類的構(gòu)造函數(shù)CA::CA()才可以,構(gòu)造函數(shù)的內(nèi)部實(shí)現(xiàn)會(huì)為內(nèi)存區(qū)域填充虛表指針,這樣對象才可以調(diào)用諸如foo虛函數(shù)。但是這樣寫代碼不夠優(yōu)雅,那么有沒有比較優(yōu)雅的方法來實(shí)現(xiàn)在一塊已經(jīng)存在的內(nèi)存上來構(gòu)建對象呢? 答案就是 placement技術(shù)。 C++中的仍然是使用new和delete來實(shí)現(xiàn)這種技術(shù)。new和delete除了實(shí)現(xiàn)默認(rèn)的操作符外還重載實(shí)現(xiàn)了如下的操作符函數(shù):

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..
}

我們稱這四個(gè)運(yùn)算符為 placement new 和 placement delete  。通過這幾個(gè)運(yùn)算符我們就可以優(yōu)雅的實(shí)現(xiàn)上述的功能:

char buf1[100];
CA *p1 = new(buf1) CA(10); //調(diào)用 operator new(size_t, void*)
p1->foo();
char *buf2 = new char[sizeof(CA)];
CA *p2 = new(buf2) CA(20);  //調(diào)用 operator new(size_t, void*)
p2->foo();
p1->~CA();
operator delete(p1, buf1); //調(diào)用 operator delete(void*, void*)
p2->~CA();
operator delete(p2, buf2); //調(diào)用 operator delete(void*, void*)
delete[] buf2;

上面的例子里面發(fā)現(xiàn)通過placement new可以很優(yōu)雅的在現(xiàn)有的內(nèi)存中構(gòu)建對象,而析構(gòu)時(shí)不能直接調(diào)用delete p1, delete p2來銷毀對象,必須人為的調(diào)用析構(gòu)函數(shù)以及placement delete 函數(shù)。并且從上面的placement delete的實(shí)現(xiàn)來看里面并沒有任何代碼,既然如此為什么還要定義一個(gè)placement   delete呢? 答案就是C++中的規(guī)定對new和delete的運(yùn)算符重載必須是要成對實(shí)現(xiàn)的。而且前面曾經(jīng)說過對delete的使用如果帶了operator前綴時(shí)就只是一個(gè)普通的函數(shù)調(diào)用。因此為了完成析構(gòu)以及和new操作符的匹配,就必須要人為的調(diào)用對象的析構(gòu)函數(shù)以及placement delete函數(shù)。
除了上面舉的例子外placement技術(shù)的使用還可以減少內(nèi)存的頻繁分配以及提升系統(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)建一個(gè)堆內(nèi)存對象,然后調(diào)用虛函數(shù)foo后再進(jìn)行銷毀。最終的結(jié)果是程序運(yùn)行時(shí)會(huì)進(jìn)行10000次的頻繁的堆內(nèi)存分配和銷毀。很明顯這是有可能會(huì)影響系統(tǒng)性能的而且還有可能發(fā)生堆內(nèi)存分配失敗的情況。而如果我們借助placement 技術(shù)就可以很簡單的解決這些問題。

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;
}

上面的例子里面只進(jìn)行了一次堆內(nèi)存分配,在循環(huán)里面都是借助已經(jīng)存在的內(nèi)存來構(gòu)建對象,不會(huì)再分配內(nèi)存了。這樣對內(nèi)存的重復(fù)利用就使得程序的性能得到非常大的提升。

new和delete運(yùn)算符重載

發(fā)現(xiàn)一個(gè)很有意思的事情就是越高級(jí)的語言就越會(huì)將一些系統(tǒng)底層的東西進(jìn)行封裝并形成一個(gè)語言級(jí)別的關(guān)鍵字來使用。比如C++中的new和delete是用于構(gòu)建和釋放堆內(nèi)存對象的關(guān)鍵字,又比如go語言中chan關(guān)鍵字是用于進(jìn)行同步或者異步的隊(duì)列數(shù)據(jù)傳輸通道。

C++語言內(nèi)置默認(rèn)實(shí)現(xiàn)了一套全局new和delete的運(yùn)算符函數(shù)以及placement new/delete運(yùn)算符函數(shù)。不管是類還是內(nèi)置類型都可以通過new/delete來進(jìn)行堆內(nèi)存對象的分配和釋放的。對于一個(gè)類來說,當(dāng)我們使用new來進(jìn)行構(gòu)建對象時(shí),首先會(huì)檢查這個(gè)類是否重載了new運(yùn)算符,如果這個(gè)類重載了new運(yùn)算符那么就會(huì)調(diào)用類提供的new運(yùn)算符來進(jìn)行內(nèi)存分配,而如果沒有提供new運(yùn)算符時(shí)就使用系統(tǒng)提供的全局new運(yùn)算符來進(jìn)行內(nèi)存分配。內(nèi)置類型則總是使用系統(tǒng)提供的全局new運(yùn)算符來進(jìn)行內(nèi)存的分配。對象的內(nèi)存銷毀流程也是和分配一致的。

new和delete運(yùn)算符既支持全局的重載又支持類級(jí)別的函數(shù)重載。下面是這種運(yùn)算符的定義的格式:

//全局運(yùn)算符定義格式
void * operator new(size_t size [, param1, param2,....]);
void operator delete(void *p [, param1, param2, ...]);
//類內(nèi)運(yùn)算符定義格式
class CA
{
 void * operator new(size_t size [, param1, param2,....]);
 void operator delete(void *p [, param1, param2, ...]);
};

對于new/delete運(yùn)算符重載我們總有如何下規(guī)則:

new和delete運(yùn)算符重載必須成對出現(xiàn)

new運(yùn)算符的第一個(gè)參數(shù)必須是size_t類型的,也就是指定分配內(nèi)存的size尺寸;delete運(yùn)算符的第一個(gè)參數(shù)必須是要銷毀釋放的內(nèi)存對象。其他參數(shù)可以任意定義。

系統(tǒng)默認(rèn)實(shí)現(xiàn)了new/delete、new[]/delete[]、 placement new / delete 6個(gè)運(yùn)算符函數(shù)。它們都有特定的意義。
你可以重寫默認(rèn)實(shí)現(xiàn)的全局運(yùn)算符,比如你想對內(nèi)存的分配策略進(jìn)行自定義管理或者你想監(jiān)測堆內(nèi)存的分配情況或者你想做堆內(nèi)存的內(nèi)存泄露監(jiān)控等。但是你重寫的全局運(yùn)算符一定要滿足默認(rèn)的規(guī)則定義。

如果你想對某個(gè)類的堆內(nèi)存分配的對象做特殊處理,那么你可以重載這個(gè)類的new/delete運(yùn)算符。當(dāng)重載這兩個(gè)運(yùn)算符時(shí)雖然沒有帶static屬性,但是不管如何對類的new/delete運(yùn)算符的重載總是被認(rèn)為是靜態(tài)成員函數(shù)。

當(dāng)delete運(yùn)算符的參數(shù)>=2個(gè)時(shí),就需要自己負(fù)責(zé)對象析構(gòu)函數(shù)的調(diào)用,并且以運(yùn)算符函數(shù)的形式來調(diào)用delete運(yùn)算符。

一般情況下你不需要對new/delete運(yùn)算符進(jìn)行重載,除非你的整個(gè)應(yīng)用或者某個(gè)類有特殊的需求時(shí)才會(huì)如此。下面的例子你可以看到我的各種運(yùn)算符的重載方法以及使用方法:

//CA.h
class CA
{
public:
 //類成員函數(shù)
 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(){}
};
//全局運(yùn)算符函數(shù),請謹(jǐn)慎重寫覆蓋全局運(yùn)算符函數(shù)。
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(); //調(diào)用void * CA::operator new(size_t size)
 CA *a2 = new CA[10]; //調(diào)用void * CA::operator new[](size_t size)
 CA *a3 = new(buf)CA(); //調(diào)用void * CA::operator new(size_t size, void *p)
 CA *a4 = new(10, 20)CA(); //調(diào)用void* CA::operator new(size_t size, int a, int b)
 delete a1; //調(diào)用void CA::operator delete(void *p)
 delete[] a2; //調(diào)用void CA::operator delete[](void *p)
 //a3用的是placement new的方式分配,因此需要自己調(diào)用對象的析構(gòu)函數(shù)。
 a3->~CA();
 CA::operator delete(a3, buf); //調(diào)用void CA::operator delete(void *p, void *p1),記得要帶上類命名空間。
 //a4的運(yùn)算符參數(shù)大于等于2個(gè)所以需要自己調(diào)用對象的析構(gòu)函數(shù)。
 a4->~CA();
 CA::operator delete(a4, 10, 20); //調(diào)用void CA::operator delete(void *p, int a, int b)
 //CB類沒有重載運(yùn)算符,因此使用的是全局重載的運(yùn)算符。
 CB *b1 = new CB(); //調(diào)用void * operator new(size_t size)
 CB *b2 = new CB[10]; //調(diào)用void * operator new[](size_t size)
 //這里你可以看到同一塊內(nèi)存可以用來構(gòu)建CA類的對象也可以用來構(gòu)建CB類的對象
 CB *b3 = new(buf)CB(); //調(diào)用void * operator new(size_t size, void *p)
 CB *b4 = new(10, 20)CB(); //調(diào)用void* operator new(size_t size, int a, int b)
 delete b1; //調(diào)用void operator delete(void *p)
 delete[] b2; //調(diào)用void operator delete[](void *p)
 //b3用的是placement new的方式分配,因此需要自己調(diào)用對象的析構(gòu)函數(shù)。
 b3->~CB();
 ::operator delete(b3, buf); //調(diào)用void operator delete(void *p, void *p1)
 //b4的運(yùn)算符參數(shù)大于等于2個(gè)所以需要自己調(diào)用對象的析構(gòu)函數(shù)。
 b4->~CB();
 ::operator delete(b4, 10, 20); //調(diào)用void operator delete(void *p, int a, int b)
 return 0;
}

我是在XCODE上測試上面的代碼的,因?yàn)橹貙懥巳值膎ew/delete運(yùn)算符,并且內(nèi)部是通過malloc來實(shí)現(xiàn)堆內(nèi)存分配的, malloc函數(shù)申明了不能返回NULL的返回結(jié)果檢測:

void *malloc(size_t __size) __result_use_check __alloc_size(1);

因此有可能你在測試時(shí)會(huì)發(fā)生崩潰的問題。如果出現(xiàn)這個(gè)問題你可以嘗試著注釋掉對全局new/delete重寫的代碼,再運(yùn)行查看結(jié)果。 可見如果你嘗試著覆蓋重寫全局的new/delete時(shí)是有可能產(chǎn)生風(fēng)險(xiǎn)的。

對象的自動(dòng)刪除技術(shù)

一般來說系統(tǒng)對new/delete的默認(rèn)實(shí)現(xiàn)就能滿足我們的需求,我們不需要再去重載這兩個(gè)運(yùn)算符。那為什么C++還提供對這兩個(gè)運(yùn)算符的重載支持呢?答案還是在運(yùn)算符本身具有的缺陷所致。我們知道用new關(guān)鍵字來創(chuàng)建堆內(nèi)存對象是分為了2步:1.是堆內(nèi)存分配,2.是對象構(gòu)造函數(shù)的調(diào)用。而這兩步中的任何一步都有可能會(huì)產(chǎn)生異常。如果說是在第一步出現(xiàn)了問題導(dǎo)致內(nèi)存分配失敗則不會(huì)調(diào)用構(gòu)造函數(shù),這是沒有問題的。如果說是在第二步構(gòu)造函數(shù)執(zhí)行過程中出現(xiàn)了異常而導(dǎo)致無法正常構(gòu)造完成,那么就應(yīng)該要將第一步中所分配的堆內(nèi)存進(jìn)行銷毀。C++中規(guī)定如果一個(gè)對象無法完全構(gòu)造那么這個(gè)對象將是一個(gè)無效對象,也不會(huì)調(diào)用析構(gòu)函數(shù)。為了保證對象的完整性,當(dāng)通過new分配的堆內(nèi)存對象在構(gòu)造函數(shù)執(zhí)行過程中出現(xiàn)異常時(shí)就會(huì)停止構(gòu)造函數(shù)的執(zhí)行并且自動(dòng)調(diào)用對應(yīng)的delete運(yùn)算符來對已經(jīng)分配的堆內(nèi)存執(zhí)行銷毀處理,這就是所謂的對象的自動(dòng)刪除技術(shù)。正是因?yàn)橛辛藢ο蟮淖詣?dòng)刪除技術(shù)才能解決對象構(gòu)造不完整時(shí)會(huì)造成內(nèi)存泄露的問題。

當(dāng)對象構(gòu)造過程中拋出異常時(shí),C++的異常處理機(jī)制會(huì)在特定的地方插入代碼來實(shí)現(xiàn)對對象的delete運(yùn)算符的調(diào)用,如果想要具體了解情況請參考C++對異常處理實(shí)現(xiàn)的相關(guān)知識(shí)點(diǎn)。

全局delete運(yùn)算符函數(shù)所支持的對象的自動(dòng)刪除技術(shù)雖然能解決對象本身的內(nèi)存泄露問題,但是卻不能解決對象構(gòu)造函數(shù)內(nèi)部的數(shù)據(jù)成員的內(nèi)存分配泄露問題,我們來看下面的代碼:

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; //這句代碼永遠(yuǎn)不會(huì)執(zhí)行
  }
  catch(int)
 {
   cout << "oops!" << endl;
 }
}

上面的代碼中可以看到類CA中的對象在構(gòu)造函數(shù)內(nèi)部拋出了異常,雖然系統(tǒng)會(huì)對p對象執(zhí)行自動(dòng)刪除技術(shù)來銷毀分配好的內(nèi)存,但是對于其內(nèi)部的數(shù)據(jù)成員m_pa來說,因?yàn)闃?gòu)造不完整就不會(huì)調(diào)用析構(gòu)函數(shù)來銷毀分配的堆內(nèi)存,這樣就導(dǎo)致了m_pa這塊內(nèi)存出現(xiàn)了泄露。怎么解決這類問題呢? 答案你是否想到了? 那就是重載CA類的new/delete運(yùn)算符。我們來看通過對CA重載運(yùn)算符解決問題的代碼:

class CA
{
public:
 CA(){
  m_pa = new int;
  throw 1;
 }
 //因?yàn)閷ο髽?gòu)造未完成所以析構(gòu)函數(shù)永遠(yuǎn)不會(huì)被調(diào)用
 ~CA()
 {
  delete m_pa;
  m_pa = NULL;
 }
 void * operator new(size_t size)
 {
  return malloc(size);
 }
 //重載delete運(yùn)算符,把已經(jīng)分配的內(nèi)存銷毀掉。
 void operator delete(void *p)
 {
  CA *pb = (CA*)p;
  if (pb->m_pa != NULL)
   delete pb->m_pa;
  free(p);
 }
private:
 int *m_pa;
};

因?yàn)镃++對自動(dòng)刪除技術(shù)的支持,當(dāng)CA對象在構(gòu)造過程中發(fā)生異常時(shí),我們就可以通過重載delete運(yùn)算符來解決那些在構(gòu)造函數(shù)中分配的數(shù)據(jù)成員內(nèi)存但又不會(huì)調(diào)用析構(gòu)函數(shù)來銷毀的數(shù)據(jù)成員的內(nèi)存問題。這我想就是為什么C++中要支持對new/delete運(yùn)算符在類中重載的原因吧。

下面看下:new和delete使用注意事項(xiàng)

1. new 和delete都是內(nèi)建的操作符,語言本身所固定了,無法重新定制,想要定制new和delete的行為,徒勞無功的行為。

2. 動(dòng)態(tài)分配失敗,則返回一個(gè)空指針(NULL),表示發(fā)生了異常,堆資源不足,分配失敗。

3. 指針刪除與堆空間釋放。刪除一個(gè)指針p(delete p;)實(shí)際意思是刪除了p所指的目標(biāo)(變量或?qū)ο蟮龋?,釋放了它所占的堆空間,而不是刪除p本身(指針p本身并沒有撤銷,它自己仍然存在,該指針?biāo)純?nèi)存空間并未釋放),釋放堆空間后,p成了空指針。

4. 內(nèi)存泄漏(memory leak)和重復(fù)釋放。new與delete 是配對使用的, delete只能釋放堆空間。如果new返回的指針值丟失,則所分配的堆空間無法回收,稱內(nèi)存泄漏,同一空間重復(fù)釋放也是危險(xiǎn)的,因?yàn)樵摽臻g可能已另分配,所以必須妥善保存new返回的指針,以保證不發(fā)生內(nèi)存泄漏,也必須保證不會(huì)重復(fù)釋放堆內(nèi)存空間。

5. 動(dòng)態(tài)分配的變量或?qū)ο蟮纳?。我們也稱堆空間為自由空間(free store),但必須記住釋放該對象所占堆空間,并只能釋放一次,在函數(shù)內(nèi)建立,而在函數(shù)外釋放,往往會(huì)出錯(cuò)。

6. 要訪問new所開辟的結(jié)構(gòu)體空間,無法直接通過變量名進(jìn)行,只能通過賦值的指針進(jìn)行訪問。

    用new和delete可以動(dòng)態(tài)開辟和撤銷地址空間。在編程序時(shí),若用完一個(gè)變量(一般是暫時(shí)存儲(chǔ)的數(shù)據(jù)),下次需要再用,但卻又想省去重新初始化的功夫,可以在每次開始使用時(shí)開辟一個(gè)空間,在用完后撤銷它。

總結(jié)

以上所述是小編給大家介紹的C++的new和delete,希望對大家有所幫助,如果大家有任何疑問請給我留言,小編會(huì)及時(shí)回復(fù)大家的。在此也非常感謝大家對腳本之家網(wǎng)站的支持!

相關(guān)文章

  • 詳解C++虛函數(shù)表存儲(chǔ)位置

    詳解C++虛函數(shù)表存儲(chǔ)位置

    相信大家知道虛表指針和虛函數(shù)存儲(chǔ)的位置,但對于虛函數(shù)表的存儲(chǔ)位置一時(shí)無法確定。本文就來和大家詳細(xì)聊聊相關(guān)內(nèi)容,希望對大家有所幫助
    2023-04-04
  • 關(guān)于c語言中輸出字符指針的相關(guān)問題

    關(guān)于c語言中輸出字符指針的相關(guān)問題

    這篇文章主要介紹了關(guān)于c語言中輸出字符指針的相關(guān)問題,具有很好的參考價(jià)值,希望對大家有所幫助。如有錯(cuò)誤或未考慮完全的地方,望不吝賜教
    2022-07-07
  • C++之vector容器的的聲明初始化和增刪改查

    C++之vector容器的的聲明初始化和增刪改查

    這篇文章主要給大家介紹了關(guān)于C++vector容器的的聲明初始化和增刪改查的相關(guān)資料,向量(Vector)是一個(gè)封裝了動(dòng)態(tài)大小數(shù)組的順序容器(Sequence Container),跟任意其它類型容器一樣,它能夠存放各種類型的對象,需要的朋友可以參考下
    2021-07-07
  • C語言執(zhí)行時(shí),程序控制臺(tái)輸出窗口 一閃而過問題及解決

    C語言執(zhí)行時(shí),程序控制臺(tái)輸出窗口 一閃而過問題及解決

    這篇文章主要介紹了C語言執(zhí)行時(shí),程序控制臺(tái)輸出窗口 一閃而過問題及解決方案,具有很好的參考價(jià)值,希望對大家有所幫助。如有錯(cuò)誤或未考慮完全的地方,望不吝賜教
    2022-11-11
  • 解決C語言輸入單個(gè)字符屏蔽回車符的問題

    解決C語言輸入單個(gè)字符屏蔽回車符的問題

    這篇文章主要介紹了解決C語言輸入單個(gè)字符屏蔽回車符的問題,具有很好的參考價(jià)值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2020-12-12
  • Qt開發(fā)之QString類的使用教程詳解

    Qt開發(fā)之QString類的使用教程詳解

    本文主要介紹了Qt中QString類的使用,文中通過示例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧
    2022-11-11
  • C語言中typedef的用法以及#define區(qū)別詳解

    C語言中typedef的用法以及#define區(qū)別詳解

    這篇文章主要給大家介紹了關(guān)于C語言中typedef用法以及#define區(qū)別的相關(guān)資料,typedef 是用來定義一種類型的新別名的,它不同于宏(#define),不是簡單的字符串替換。而#define只是簡單的字符串替換(原地?cái)U(kuò)展),需要的朋友可以參考下
    2021-07-07
  • 希爾排序算法的C語言實(shí)現(xiàn)示例

    希爾排序算法的C語言實(shí)現(xiàn)示例

    這篇文章主要介紹了希爾排序算法的C語言實(shí)現(xiàn)示例,希爾排序可以看作為一種高級(jí)的插入排序,需要的朋友可以參考下
    2016-04-04
  • C++ 哈夫曼樹對文件壓縮、加密實(shí)現(xiàn)代碼

    C++ 哈夫曼樹對文件壓縮、加密實(shí)現(xiàn)代碼

    這篇文章主要介紹了C++ 哈夫曼樹對文件壓縮、加密實(shí)現(xiàn)代碼,具有一定的參考價(jià)值,感興趣的小伙伴們可以參考一下
    2017-08-08
  • 詳解C++?轉(zhuǎn)換的非正式分類

    詳解C++?轉(zhuǎn)換的非正式分類

    C++?正式分類方法是直接按語法分類,分為:隱式轉(zhuǎn)換和顯示轉(zhuǎn)換。這篇文章主要介紹了C++?轉(zhuǎn)換的非正式分類,需要的朋友可以參考下
    2022-01-01

最新評論