析构函数 没定义函数体,  当采用不同使用方式， 编译结果不一样：
 
方式1 ：  CTest *Test3 = new CTest();  链接成功， 此时如果加上 delete Test3 ;  会报 链接错误
 
方式2：   CTest Test4; 会报 链接错误。
 
如果加上析构函数函数体测试， 对于方式1 ，当不调用delete, 离开作用域并没有调用构造函数。   方式2 离开作用域就会调用析构函数
 
链接错误：
 
1>main.obj : error LNK2019: 无法解析的外部符号 "public: __thiscall CTest::~CTest(void)" (??1CTest@@QAE@XZ)，该符号在函数 "public: void * __thiscall CTest::`scalar deleting destructor'(unsigned int)" (??_GCTest@@QAEPAXI@Z) 中被引用
 1>D:\测试程序\test\Debug\test.exe : fatal error LNK1120: 1 个无法解析的外部命令
 

C++中关于类的析构函数无法调用的问题
 
代码如下:
 
#include <iostream>
using namespace std;
class A {//创建一个A类
public:
	A(int a) {
		cout << "A()..." << endl;
		m_a = a;
	}
	void printA() {
		cout << "m_a=" << m_a << endl;
	}
	~A() {//创建A的析构函数
		cout << "~A..." << endl;
	}
private:
	int m_a;
};
class B {//创建一个B类
public:
	B(A&a1,A&a2,int id) :a1(a1), a2(a2) {
		cout << "B()...." << endl;
		m_id = id;
	}
	void printB() {
		cout << "id=" << m_id << endl;
		a1.printA();
		a2.printA();
	}
	~B() {//创建B类的析构函数
		cout << "~b...." << endl;
	}
private:
	int m_id;
	A a1;
	A a2;
};
int main() {
	A a1(10), a2(100);
	B b(a1, a2, 1000);
	b.printB();
	system("pause");//暂停程序
	return 0;
}
 
我们知道析构函数在类结束时会自动调用,但当我们用system(“pause”)暂停程序时,析构函数还没有执行会被暂停,要想析构函数被调用应该去掉system(“pause”).

一个示例：
 
class Parent
{
public:
	Parent() {}
	virtual ~Parent() = 0; 
};

class Child : public Parent
{
	//具体实现
};

int main()
{
	{
		Parent* p = new Child();
	}

	system("pause");
    return 0;
}
 
编译时会报如下错误：
 
LNK2019	无法解析的外部符号 "public: virtual __thiscall Parent::~Parent(void)" (??1Parent@@UAE@XZ)，该符号在函数 "public: virtual __thiscall Child::~Child(void)" (??1Child@@UAE@XZ) 中被引用	vptr	E:\c++\study\纯虚析构函数\vptr\vptr\vptr.obj	1	
 
分析：
 
父类的析构函数定义为了纯虚的析构函数，析构函数的执行顺序为先析构子类，再析构父类。当析构父类的时候，找不到函数体，故编译失败。
 
解决：
 
class Parent
{
public:
	Parent() {}
	virtual ~Parent() = 0;  //可以这样定义，但是如果作为父类，需要单独定义函数体
};

Parent::~Parent()
{

}
 
对纯虚析构函数进行单独定义即可。

我们知道对象在结束其生命周期之前，都会调用析构函数以完成必要的清理工作；派生类调用的析构函数顺序是“先子类，后基类”； 这篇文章用于总结当析构函数是普通析构函数、虚析构函数、纯虚析构函数时,我们使用delete运算符删除一个指针对象时，析构函数会有什么情况发生；
 
####普通析构函数####
 
CBase是基类，CDerive是其子类，类源码代码如下：
 
class CBase
{
public:
    CBase(){}
    //基类析构函数
    ~CBase(){ cout << "CBase Destructor" << endl; } 
private:
    int a;
};

class CDerive:public CBase
{
public:
    CDerive(){}   
    //子类析构函数
    ~CDerive(){ cout << "CDerive Destructor" << endl; }
private:
    int b;
};
 
测试代码如下：
 
//case1
CDerive *pDeriveObj = new CDerive();
delete pDeriveObj;

//case2
//基类指针对象可以指向派生类，体现基类和派生类赋值兼容关系(不同类型可以转化和赋值),
//但是pBaseObj只能访问基类成员，不能访问派生类成员
CBase* pBaseObj = new CDerive();
delete pBaseObj; //等价于删除基类对象
 
测试结果:
 
/* case 1
先析构子类:CDerive Destructor
后析构基类:CBase Destructor
*/

/* case2
仅析构基类:CBase Destructor
*/
 
总结：
 
若delete运算符删除的是子类指针对象，则会调用子类和基类的析构函数；
若析构函数是非虚的，即使基类指针指向的是子类对象，则delete 指针对象时，也仅调用基类的析构函数；
 
####虚析构函数####
 
当基类中的析构函数设置为虚函数时，我们在delete 基类指针对象时，能根据实际类型完成对象的清理工作；源码如下：
 
class CBase
{
public:
    CBase(){}
    //基类虚析构函数
    virtual ~CBase(){ cout << "CBase Destructor" << endl; } 
private:
    int a;
};

class CDerive:public CBase
{
public:
    CDerive(){}   
    //子类虚析构函数
    virtual ~CDerive(){ cout << "CDerive Destructor" << endl; }
private:
    int b;
};
 
测试代码：
 
 //指向基类对象
 CBase*pBaseObj_case1 = new CBase();
 delete pBaseObj_case1;
 
 //指向子类对象
 CBase*pBaseObj_case2 = new CDerive();
 delete pBaseObj_case2;
 
运行结果：
 //case1
 CBase Destructor
 
//case2
 CDerive Destructor ->先子类
 CBase Destructor ->后基类
 
总结：
 当基类的析构函数为虚函数时，基类指针指向的是子类对象时，使用delete运算符删除指针对象，析构函能够按照“先子类，后基类”的原则完成对象清理；这样在多重继承的类中，能够保证每个类都能够得到正确的清理；比如基类和子类的缓冲区都能被释放；
 
####纯虚析构函数####
 
当基类中有纯虚函数时，基类是不能被实例化的，需要在子类中重写该纯虚函数；对于纯虚析构函数有点特殊，源码如下：
 
class CBase
{
public:
    CBase(){}
    //基类析构函数
    virtual ~CBase()= 0;
private:
    int a;
};

class CDerive:public CBase
{
public:
    CDerive(){}   
    //子类析构函数
    virtual ~CDerive(){ cout << "CDerive Destructor" << endl; }
private:
    int b;
};
 
测试代码：
 
CBase*pBaseObj = new CDerive();
delete pBaseObj;
 
当我们编译代码时，会发现代码编译不过提示：
 “error LNK2019: 无法解析的外部符号 “public: virtual __thiscall CBase::~CBase(void)” (??1CBase@@UAE@XZ)，该符号在函数 “public: virtual __thiscall CDerive::~CDerive(void)” (??1CDerive@@UAE@XZ) 中被引用”
 
 原因是子类析构时需要调用基类的析构函数，但发现代码中没有实现CBase析构函数，导致编译异常；
 解决办法就是我们在CBase类外实现其函数体，而不是在子类中重写，而且~CDerive函数也是虚函数，即使其函数名不同；这就是和其他纯虚函数有特殊的地方；
 
 
我们需要在CBase类外增加如下的析构函数：
 
CBase::~CBase()
{ 
    cout << "CBase Destructor" << endl; 
} 
 
这样得到的运行结果是：
 CDerive Destructor ->先子类
 CBase Destructor ->后基类
 
####总结####
 
最好把基类的析构函数声明为虚函数。这将使所有派生类的析构函数自动成为虚函数。这样，如果程序中显式地用了delete运算符准备删除一个对象，而delete运算符的操作对象用了指向派生类对象的基类指针，则系统会调用相应类的析构函数。
 
专业人员一般都习惯声明虚析构函数，即使基类并不需要析构函数，也显式地定义一个函数体为空的虚析构函数，以保证在撤销动态分配空间时能得到正确的处理。
 
参考资料：
 
http://c.biancheng.net/cpp/biancheng/view/247.html
 
http://blog.csdn.net/yapian8/article/details/46418687