1、為啥繼承時基類的解構函式宣告為虛擬函式？

文字描述太抽象了，直接用程式碼給出答案。

（1）第一段程式碼：

#include<iostream>
using  namespace std ;

class Base
{
public:
	Base()
	{
		
		cout << "基類的建構函式被呼叫了" << endl;
		
	}
	 ~Base()
	{
		
		cout << "基類的解構函式被執行了" <<endl;
	}

};

class Derived :public Base
{
public:
	Derived(char *str = "")
	{
		if (str == NULL)
		{
			_Dstr = new char[1];
			*_Dstr = '\0';
		}
		else
		{
			_Dstr = new char [strlen(str) + 1];
			strcpy(_Dstr, str);
		}
		cout << "派生類的建構函式被呼叫了" << endl;

	}
	~Derived()
	{
		if (_Dstr != NULL)
		{
			delete [] _Dstr;
			_Dstr = NULL;
		}
		cout << "派生類的解構函式被執行了" <<endl;
	}
private:
	char *_Dstr;
};


void test()
{
	Base B1;
	Base & b = B1;   //基類的引用或指標指向基類物件。
}


int main()
{
	test();

	cout << "hello..." <<endl;
	system("pause");
	return 0;
}
 

（2）第二段程式碼

#include<iostream>
using  namespace std ;

class Base
{
public:
	Base()
	{
		
		cout << "基類的建構函式被呼叫了" << endl;
		
	}
	 ~Base()
	{
		
		cout << "基類的解構函式被執行了" <<endl;
	}

};

class Derived :public Base
{
public:
	Derived(char *str = "")
	{
		if (str == NULL)
		{
			_Dstr = new char[1];
			*_Dstr = '\0';
		}
		else
		{
			_Dstr = new char [strlen(str) + 1];
			strcpy(_Dstr, str);
		}
		cout << "派生類的建構函式被呼叫了" << endl;

	}
	~Derived()
	{
		if (_Dstr != NULL)
		{
			delete [] _Dstr;
			_Dstr = NULL;
		}
		cout << "派生類的解構函式被執行了" <<endl;
	}
private:
	char *_Dstr;
};


void test()
{

	Base * b = new Derived("str");   //基類的引用或指標指向派生類物件。
	delete b;
}


int main()
{
	test();

	cout << "hello..." <<endl;
	system("pause");
	return 0;
}
 

//分析答案發現析構時，只調用了基類的解構函式，沒有呼叫派生類的解構函式，導致派生類記憶體洩露，

（3）第三段程式碼

#include<iostream>
using  namespace std ;

class Base
{
public:
	Base()
	{
		
		cout << "基類的建構函式被呼叫了" << endl;
		
	}
	 virtual ~Base()  //將基類的解構函式宣告為虛擬函式。 
	{
		
		cout << "基類的解構函式被執行了" <<endl;
	}

};

class Derived :public Base
{
public:
	Derived(char *str = "")
	{
		if (str == NULL)
		{
			_Dstr = new char[1];
			*_Dstr = '\0';
		}
		else
		{
			_Dstr = new char [strlen(str) + 1];
			strcpy(_Dstr, str);
		}
		cout << "派生類的建構函式被呼叫了" << endl;

	}
	~Derived()
	{
		if (_Dstr != NULL)
		{
			delete [] _Dstr;
			_Dstr = NULL;
		}
		cout << "派生類的解構函式被執行了" <<endl;
	}
private:
	char *_Dstr;
};


void test()
{

	Base * b = new Derived("str");   //基類的引用或指標指向派生類物件。
	delete b;
}


int main()
{
	test();

	cout << "hello..." <<endl;
	system("pause");
	return 0;
}
 

//答案分析：析構時，先呼叫了派生類的解構函式，再呼叫基類的解構函式，不存在記憶體洩露。反過來看原始碼只是發現只是將基類的解構函式宣告為虛擬函式。

結論： 繼承時，如果派生類有資源需要自己手動釋放，最好將基類的解構函式宣告為虛擬函式，這樣我們可以通過基類的指標或引用去釋放子類的資源。防止記憶體洩露。

2.當我們想要繼承一個抽象類的時候，但是還不能確定抽象類的那些成員是純虛擬函式，我們可以將抽象類的解構函式宣告為純虛擬函式。

（1）第一段程式碼

#include<iostream>
using  namespace std ;

class Abstract
{
public:
	virtual ~Abstract() = 0;
};

class Derived: public Abstract
{
public:
	Derived()
	{
		cout << "派生類的建構函式被執行了" <<endl;
	}
	~Derived()
	{
		cout << "派生類的解構函式被執行了" << endl;
	}
};

void test()
{
	Derived d;
}

int main()
{
	test();

	cout << "hello..." <<endl;
	system("pause");
	return 0;
}

如果我們單純的直接這麼寫，我們發現編譯器報錯，報下列的錯誤：

抽象類的解構函式.obj : error LNK2019: 無法解析的外部符號 "public: virtual __thiscall Abstract::~Abstract(void)" ([email protected]@[email protected])，該符號在函式 [email protected]@[email protected]

通過分析：我們發現定義派生類物件時，會先呼叫抽象類的建構函式，抽象類的建構函式沒有顯示的給出，編譯器合成一個預設的建構函式，再呼叫派生類的建構函式，析構時，先呼叫派生類的解構函式，最後呼叫抽象類的解構函式，但是抽象類的解構函式已經顯示的聲明瞭，因此會呼叫程式設計師自己寫的，但是這個解構函式沒有函式體，所以編譯器報錯，說無法解析的外部符號，

解決方案：給抽象類的解構函式定義。看下面的程式碼：

（2）第二段程式碼：

#include<iostream>
using  namespace std ;

class Abstract
{
public:
	virtual ~Abstract() = 0;
	
};

 Abstract:: ~Abstract()
{
	cout << "抽象類的解構函式被執行了" <<endl;
};

class Derived: public Abstract
{
public:
	Derived()
	{
		cout << "派生類的建構函式被執行了" <<endl;
	}
	~Derived()
	{
		cout << "派生類的解構函式被執行了" << endl;
	}
};

void test()
{
	Derived d;
}

int main()
{
	test();

	cout << "hello..." <<endl;
	system("pause");
	return 0;
}