C++中的析構函數
簡介
析構函數（Destructors），是對象的成員函數，沒有返回值也沒有參數，且一個類只有一個析構函數，當對象被銷毀的時候調用，被銷毀通常有這么幾個情況。
- 函數執行結束
- 程序執行結束
- 程序塊包含的局部變量
- delete操作
什么時候要自己寫析構函數？
編譯器會自動創建默認的析構函數，通常都沒有問題，但是當我們在類中動態分配了內存空間時，我們需要手段的回收這塊空間，防止內存溢出。就像這樣
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;
}
私有的析構函數
可以將析構函數的訪問權限設置為private，設置時沒有問題的，但是一個問題就是，通常的手段就沒法調用析構函數了。
如下所示，程序結束后要調用析構函數，但是析構函數時私有的沒法調用，所以會編譯出錯。
#include <iostream>
using namespace std;
class Test {
private:
~Test() {}
};
int main()
{
Test t;
}
以下這樣不會有問題，因為沒有對象被建立，也不用析構
int main()
{
Test* t;
}
以下這樣也不會有問題，因為動態分配的內存需要程序員手段釋放，所以程序結束時沒有釋放內存，也沒有調用析構函數。這里插一句，動態分配的內存如果不手動釋放，程序結束后也會不會釋放，但是現代操作系統可以幫我們釋放，因為這個動態分配的內存和這個進程有關，操作系統應該可以捕獲到這個泄露的內存從而釋放。（查資料看到的）
int main()
{
Test* t = new Test;
}
如果使用delete來刪除對象，會編譯出錯
int main()
{
Test* t = new Test;
delete t;//編譯出錯，無法調用私有的析構函數
}
可以利用Friend函數，進行對象的銷毀，因為Friend可以訪問私有成員，所以可以訪問析構函數。
#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() {}
};
那么什么時候需要使用私有的析構函數呢？當我們只希望動態分配對象空間（在堆上）時候，用私有析構，就防止了在棧上分配，因為在編譯階段就會出錯。
虛析構函數
當類用到多態的特性時候，使用虛析構函數。看如下的例子。
#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;
}
例子里的析構函數都不是虛函數，當我們想用基類的指針來刪除派生類對象的時候，就出現了問題，“undefined behavior”，c++標准里規定，只由編譯器實現，通常這時不會報錯，會調用基類的析構函數。但這應該不是我們想要的，這會導致內存泄漏。所以要把析構函數置為虛函數。(msvc似乎不用給析構函數加virtual，默認就是虛的，gcc沒有默認還是要加的)
另外虛析構函數可以是純虛析構函數，但是要提供函數體，不然沒法析構，因為虛析構函數和一般的虛函數的overide還不一樣，虛析構函數要挨個執行，不提供函數體，會編譯出錯。
析構函數執行的順序
派生類，成員對象，基類這樣
class B
{public: virtual ~B(){cout<<"基類B執行了"<<endl; }
};
class D
{public:virtual ~D(){cout<<"成員D執行了"<<endl; }
} ;
class E
{public:virtual ~E(){cout<<"成員E執行了"<<endl; }
} ;
class A
{public:virtual ~A(){cout<<"基類A執行了"<<endl;};
};
class C:public A,B
{
public:virtual ~C(){cout<<"派生類執行了"<<endl;};
private:
E e;
D d;
};
int main()
{
C *c;
c=new C();
delete c;
}
結果為：
- 派生類執行了
- 成員D執行了
- 成員E執行了
- 基類B執行了
- 基類A執行了
參考
- [1]什么時候使用虛函數https://stackoverflow.com/questions/461203/when-to-use-virtual-destructors
- [2]析構函數https://www.geeksforgeeks.org/destructors-c/
- [3]虛析構函數https://www.geeksforgeeks.org/virtual-destructor/
- [4]純析構函數https://www.geeksforgeeks.org/pure-virtual-destructor-c/