Cpp--析构函数作虚函数引出问题

当派生类对象经由一个基类指针被删除，而该基类带着一个非虚析构函数，其结果未有定义-实际执行时通常发生的是对象的派生成分没被销毁。

给基类一个虚析构函数，此后删除派生类对象就会销毁整个对象，包括所有的派生类成分。

任何类只要带有virtual函数就几乎确定应该也有一个virtual析构函数。如果类不含virtual函数，通常表明它并不意图被用作一个基类或者不需要多态性。

当然也并不是盲目设定为virtual函数，只有当类内含至少一个virtual函数，才为它声明virtual析构函数。

下面看一段代码：

#include <iostream>
using namespace std;

class Person
{
public:
virtual ~Person()                    //析构函数声明为虚函数
{
   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;
}

 

运行结果为：

若是在基类中不加virtual，也即不定义基类虚析构函数，则结果为：

只有在用基类的指针指向派生类的时候，才会出现这种情况。因为这个时候虚函数发挥了动态的作用。

析构函数执行时先调用派生类的析构函数，其次才调用基类的析构函数。如果析构函数不是虚函数，而程序执行时又要通过基类的指针去销毁派生类的动态对象，那么用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；

运行结果会出错。

反正是只要基类析构没有定义为virtual，而派生类（可能有多层）中有把析构定义为virtual的，此时用基类的指针指向派生类，再delete，会出错。

而：

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;

运行结果为：

OneSt::~OneSt()

Student::~Student()

Person::~Person()

是可以运行的。

C++并没有类似JAVA的final classes或C#的sealed classes那样的“禁止派生”机制。

有时候可以使class带一个纯虚析构函数，纯虚函数导致抽象的类（不能被实体化的类，也就是说，你不能为那种类创建对象），由于抽象类总是希望被当做基类来用，而基类应该有个virtual析构函数，并且由于纯虚函数会导致抽象类，所以解决方案为：为你希望成为抽象的类声明一个纯虚析构函数。

class AWOV{   
public:
	virtual ~AWOV() = 0;  //声明纯虚析构函数
};

这里类有个纯虚函数，所以它是个抽象类，又它有个虚析构函数，所以不必担心析构函数的问题。

但是必须为这个纯虚析构函数提供一份定义：

AWOV::~AWOV（）｛｝  //纯虚析构函数的定义

需要注意的是：并不是所有的基类设计都是为了多态。标准string和STL容器都不被设计作为基类 使用，更不要说是作为多态。