C++之构造函数与析构函数

首先，在栈里声明两个对象bs、sc，看看编译器是如何自动调用的。

#include<iostream>
using namespace std;
class Base{
public:
	Base(){cout<<"consttruct in Base\n";}
	~Base(){cout<<"destructing Base"<<endl;}
};

class SubClass : public Base{
public:
	SubClass(){cout<<"construct in SubClass\n";}
	~SubClass(){cout<<"destructing SubClass"<<endl;}
};

void main(){
	cout<<"first:\n";
	Base bs;
	cout<<"second:\n";
	SubClass sc;
	cout<<"end!\n";
}

结果显示：

first:
consttruct in Base
second:
consttruct in Base
construct in SubClass //先调用基类构造函数，再调用派生类构造函数
end!
destructing SubClass 
destructing Base  //先调用派生类析构函数，再调用基类析构函数
destructing Base

然后在堆中new出两个对象，类的定义如上，main()函数如下：

void mian(){
	cout<<"first:\n";
	Base *bs = new Base;
	cout<<"second:\n";
	SubClass *sc = new SubClass;
	cout<<"end!\n";
}

运行结果显示：

first:
construct in Base
second:
construct in Base
construct in SubClass

说明编译器没有调用析构函数，因为指向new出来的对象的指针没有delete，可以通过分别增加两个delete，来释放资源；

void main(){
	cout<<"first:\n";
	Base *bs = new Base;
	cout<<"second:\n";
	SubClass *sc = new SubClass;
	delete bs;
	delete sc;
	cout<<"end!\n";
}

运行结果：

first:
consttruct in Base
second:
consttruct in Base
construct in SubClass
destructing Base
destructing SubClass
destructing Base
end!

 

当然此处也可以不通过多次delete的方式来释放资源，另外定义一个函数

void del(Base *p){
	delete p;
}
void main(){	
	cout<<"first:\n";	Base *bs = new Base;	
	cout<<"second:\n";	SubClass *sc = new SubClass;	
	del(bs); //释放指向父类对象的指针		
	del(sc); //释放指向子类对象的指针	
	cout<<"end!\n";
} 

运行后发现，其实不然，当del(sc)后，并没有先调用派生类的析构函数，再调用基类的析构函数，而是直接调用了基类的构造函数，这是为什么呢？

当传递sc指针给del（Base *p）时，由于析构函数并没有定义为虚函数，所以在析构时，不能够动态绑定。

因此，应将基类的析构函数定义为虚函数：

	virtual ~Base(){//content};