詳解C++中的析構函數(shù)

更新時間：2020年06月20日 11:15:38 作者：芒果和小貓

這篇文章主要介紹了C++中的析構函數(shù)的相關知識，文中講解非常詳細，代碼幫助大家更好的理解和學習，感興趣的朋友可以了解下

簡介

析構函數(shù)（Destructors），是對象的成員函數(shù)，沒有返回值也沒有參數(shù)，且一個類只有一個析構函數(shù)，當對象被銷毀的時候調用，被銷毀通常有這么幾個情況。

函數(shù)執(zhí)行結束
程序執(zhí)行結束
程序塊包含的局部變量
delete操作

什么時候要自己寫析構函數(shù)？

編譯器會自動創(chuàng)建默認的析構函數(shù)，通常都沒有問題，但是當我們在類中動態(tài)分配了內存空間時，我們需要手段的回收這塊空間，防止內存溢出。就像這樣

class String 
{ 
private: 
	char *s; 
	int size; 
public: 
	String(char *); // constructor 
	~String();	 // destructor 
}; 
 
String::String(char *c) 
{ 
	size = strlen(c); 
	s = new char[size+1]; 
	strcpy(s,c); 
} 
 
String::~String() 
{ 
	delete []s; 
}

私有的析構函數(shù)

可以將析構函數(shù)的訪問權限設置為private，設置時沒有問題的，但是一個問題就是，通常的手段就沒法調用析構函數(shù)了。

如下所示，程序結束后要調用析構函數(shù)，但是析構函數(shù)時私有的沒法調用，所以會編譯出錯。

#include <iostream> 
using namespace std; 
class Test { 
private: 
	~Test() {} 
}; 
int main() 
{ 
	Test t; 
}

以下這樣不會有問題，因為沒有對象被建立，也不用析構

int main() 
{ 
 Test* t;           
}

以下這樣也不會有問題，因為動態(tài)分配的內存需要程序員手段釋放，所以程序結束時沒有釋放內存，也沒有調用析構函數(shù)。這里插一句，動態(tài)分配的內存如果不手動釋放，程序結束后也會不會釋放，但是現(xiàn)代操作系統(tǒng)可以幫我們釋放，因為這個動態(tài)分配的內存和這個進程有關，操作系統(tǒng)應該可以捕獲到這個泄露的內存從而釋放。（查資料看到的）

int main() 
{ 
 Test* t = new Test; 
}

如果使用delete來刪除對象，會編譯出錯

int main() 
{ 
 Test* t = new Test;
 delete t;//編譯出錯，無法調用私有的析構函數(shù) 
}

可以利用Friend函數(shù)，進行對象的銷毀，因為Friend可以訪問私有成員，所以可以訪問析構函數(shù)。

#include <iostream> 

class Test { 
private: 
	~Test() {} 
	friend void destructTest(Test*); 
}; 

void destructTest(Test* ptr) 
{ 
	delete ptr; 
} 

int main() 
{ 
	Test* ptr = new Test; 
	destructTest(ptr); 

	return 0; 
}

或者給類寫一個銷毀的方法，在需要銷毀的時候調用。

class Test { 
public:
 destroy(){delete this};
private: 
	~Test() {} 
};

那么什么時候需要使用私有的析構函數(shù)呢？當我們只希望動態(tài)分配對象空間（在堆上）時候，用私有析構，就防止了在棧上分配，因為在編譯階段就會出錯。

虛析構函數(shù)

當類用到多態(tài)的特性時候，使用虛析構函數(shù)?？慈缦碌睦?。

#include <iostream>
using namespace std;
class Base
{
public:
 Base(){
  cout << "Base Constructor Called\n";
 }
 ~Base(){
  cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
  cout << "Derived constructor called\n";
 }
 ~Derived1(){
  cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

例子里的析構函數(shù)都不是虛函數(shù)，當我們想用基類的指針來刪除派生類對象的時候，就出現(xiàn)了問題，“undefined behavior”，c++標準里規(guī)定，只由編譯器實現(xiàn)，通常這時不會報錯，會調用基類的析構函數(shù)。但這應該不是我們想要的，這會導致內存泄漏。所以要把析構函數(shù)置為虛函數(shù)。(msvc似乎不用給析構函數(shù)加virtual，默認就是虛的，gcc沒有默認還是要加的)

另外虛析構函數(shù)可以是純虛析構函數(shù)，但是要提供函數(shù)體，不然沒法析構，因為虛析構函數(shù)和一般的虛函數(shù)的overide還不一樣，虛析構函數(shù)要挨個執(zhí)行，不提供函數(shù)體，會編譯出錯。

析構函數(shù)的執(zhí)行順序

派生類，成員對象，基類這樣

class B
{public: virtual ~B(){cout<<"基類B執(zhí)行了"<<endl; }
};

class D
{public:virtual ~D(){cout<<"成員D執(zhí)行了"<<endl; }
} ;

class E
{public:virtual ~E(){cout<<"成員E執(zhí)行了"<<endl; }
} ;

class A
{public:virtual ~A(){cout<<"基類A執(zhí)行了"<<endl;}; 
};

class C:public A,B
{
 public:virtual ~C(){cout<<"派生類執(zhí)行了"<<endl;};
 private:
  E e;
  D d;
};

int main() 
{ 
 C *c;
 c=new C();
 delete c;
}

結果為