说明:
1.基类的析构函数被声明为虚函数后,派生类的析构函数默认也为虚函数;和一般的虚函数在继承关系中表现的一样,只是名字不再一样了。
2.编译器给析构函数中插入额外的代码规律和构造函数的一样,只是顺序相反!(不确认,待解决)
3. class A{}; A a; A b=a;注意第三句调用的是copy constructor 而不是copy assignment operator(已确认)。
4.
先看下面一段程序:
#include
using namespace std;
class Person
{
public:
virtual ~Person() //加了virtual,将析构函数声明为虚函数
{
cout << "Person::~Person()" << endl;
}
};
class Student : public Person
{
public:
~Student() // virtual可加可不加
{
cout << "Student::~Student()" << endl;
}
};
int main()
{
Person *pt1 = new Person;
Person *pt2 = new Student; // 用基类的指针指向派生类
// Student *pt3 = new Person; // 不能用派生类指针指向基类,错误!
Student *pt4 = new Student;
delete pt1;
cout << "*********" << endl;
delete pt2;
cout << "*********" << endl;
//delete pt3;
//cout << "*********" << endl;
delete pt4;
cout << "*********" << endl;
return 0;
}
运行结果:
Person::~Person()
***********
Student::~Student()
Person::~Person()
**********
Student::~Student()
Person::~Person()
**********
如果在基类中析构函数不加virtual,结果为:
Person::~Person()
***********
Person::~Person()
**********
Student::~Student()
Person::~Person()
**********
可以看出:只有在用基类的指针指向派生类的时候,才会出现这种情况。因为这个时候虚函数发挥了动态的作用。
析构函数执行时先调用派生类的析构函数,其次才调用基类的析构函数。如果析构函数不是虚函数,而程序执行时又要通过基类的指针去销毁派生类的动态对象,那么用delete销毁对象时,只调用了基类的析构函数,未调用派生类的析构函数。这样会造成销毁对象不完全。
如果在上面的例子中,基类中未定义virtual析构函数,而派生类中定义了virtual的析构函数,此时用基类指针指向派生类,再delete掉,
即:
class Person
{
public:
~Person()
{
cout << "Person::~Person()" << endl;
}
};
class Student : public Person
{
public:
virtual ~Student()
{
cout << "Student::~Student()" << endl;
}
};
Person * pt = new Student;
delete pt;
运行结果会出错。(注:这个实验我也做过,但不知道原理,不知道如何解释)2016.11.7更正
运行结果为:
Person::~Person()
解释如下:
1. 析构函数跟普通成员没有什么不同,只是编译器在会在特定的时候自动调用析构函数(离开作用域或者执行delete操作);
2. 对于一个成员函数调用(不论是通过对象obj.func还是通过对象指针obj->func),到底是直接调用还是通过虚函数表调用,在编译的时候是确定的,取决于这个函数是不是虚函数;
3. 综上,如果析构不声明为虚函数,那么delete pBase,就被编译器解释为 Base::~Base,否则被编译器解释为 this->virtual_function_table[#析构在虚函数表的偏移]
---------------------------------------------------------------------------------------------------------------------
再例:
class Person
{
public:
~Person()
{
cout << "Person::~Person()" << endl;
}
};
class Student : public Person
{
public:
virtual ~Student()
{
cout << "Student::~Student()" << endl;
}
};
class OneSt : public Student
{
public:
~OneSt()
{
cout << "OneSt::~OneSt()" << endl;
}
};
如果用
Student * pt = OneSt;
delete pt;
运行结果为:(注:这个例子没有实验,也不知道该怎么解释只能先这么记忆了);(现在能解释了(2016.11.7):结合上面两个例子即可理解!)
OneSt::~OneSt()
Student::~Student()
Person::~Person()
Effective C++ (第7条:要将多态基类的析构函数声明为虚函数)
注:以上全部是虚析构函数为例进行的实验,其实验结构的规律同样适用于一般的虚函数,一般的虚函数都是同名的,虚的析构函数的名字不同,忽略掉这一条,虚析构函数与一般的虚函数所适用的规律一致。
以上,除黑色字体外均为引用他人文章,红色字体为个人思考。
但是,看到此处只能达到知其然的境界,但是不知其所以然,于是我进一步百度,看到了一篇关于虚函数和虚函数表的文章,很棒,我也将其转载过来。链接如下:
点击打开链接
看了这篇文章之后就明白,一般的虚函数在使用基类指针指向一个new出来的父类的对象时,其调用虚函数的原理。
例A:
Person *pt2 = new Student;
pt2->GetIdentify();
(注:GetIdentify()函数为Person类和Student类中定义的虚函数)
就会调用Student类的GetIdentify()函数,这样就实现了多态。
但是,到目前为止还是不能明白虚析构函数的在此种情况下,函数的调用原理是怎么样的,百度了多次还是没有很好的解释,但据说
《深入探索C++对象模型》(侯杰)一书中有详细的原理介绍,有待进一步研究……(遗留问题一:寻找合理的原理解释,待续)
答遗留问题一:以上例子已经解释清楚,详细细节还需要进一步研究。
研究完这这篇文章点击打开链接(文章二)似乎可以总结如下:
1.如文章二所示当DoSomething在派生类中重写时(注意均不是虚函数),如果以
ClxBase *p = new ClxDerived; p->DoSomething();形式调用 DoSomething时,其输出结过证明其调用的是基类的DoSomething函数。
2.基于1的结论,如例A的例子,虽然pt2指向的空间是一个Student类的一个实例的空间,但是pt2仍是一个Person类对象类型的指针,当执行delete pt2这样一个操作时,其仍然是按照Person类来对待,此时如果Person的析构函数不是虚函数的话,就会直接调用他的析构函数,但是如果其析构函数是虚函数时,根据多态的特性,就会调用派生类的析构函数,如果调用了派生类的析构函数,又因为派生类的析构函数是一层层的调用下去的,所以就调用了基类的析构函数。虽然解释通了,但还需要研究下原理(同遗留问题一)!(2016.11.7更新,按上文“解释如下”理解)
此时我又有了另外两个疑问,虽然我已经接受并记住,类的默认构造函数的调用顺序是从基类自动到派生类。析构函数的调用顺序是从派生类自动到基类,但其原理是什么?(遗留问题二)
答:没有什么原理,编译器在插入必要的代码时就是按照逆顺序来操作的!至于基类的析构函数和成员变量的析构函数的调用顺序还需要确认(遗留问题三)!
2015.4.9