把类的析构函数写成虚函数的用意

博客分类： vc++
 
Cpp代码 复制代码  收藏代码
  1. #include <iostream.h>   
  2. class Base    
  3. {    
  4. public:    
  5. Base() { mPtr = new int; }    
  6. ~Base() { delete mPtr; cout<<"Base::Destruction"<<endl;}    
  7. private:    
  8.   int* mPtr;    
  9. } ;   
  10.   
  11. class Derived : public Base    
  12. {    
  13. public:    
  14.   Derived() { mDerived = new long; }    
  15.   ~Derived() { delete mDerived; cout<<"Derived::Destruction"<<endl;}    
  16. private:    
  17.   long* mDerived;    
  18. } ;   
  19.   
  20. void main()    
  21. {    
  22.   Base* p = new Derived;    
  23.   delete p;    
  24. }   

#include <iostream.h>
class Base 
{ 
public: 
Base() { mPtr = new int; } 
~Base() { delete mPtr; cout<<"Base::Destruction"<<endl;} 
private: 
  int* mPtr; 
} ;

class Derived : public Base 
{ 
public: 
  Derived() { mDerived = new long; } 
  ~Derived() { delete mDerived; cout<<"Derived::Destruction"<<endl;} 
private: 
  long* mDerived; 
} ;

void main() 
{ 
  Base* p = new Derived; 
  delete p; 
}

 

输出结果只有：Base::Destruction
以上代码会产生内存泄露，因为new出来的是Derived类资源，采用一个基类的指针来接收，析构的时候，编译器因为只是知道这个指针是基类的，所以只将基类部分的内存析构了，而不会析构子类的，就造成了内存泄露，如果将基类的析构函数改成虚函数，就可以避免这种情况，因为虚函数是后绑定，其实就是在虚函数列表中， 析构函数将基类的析构函数用实际对象的一组析构函数替换掉了，也就是先执行子类的虚函数再执行父类的虚函数，这样子类的内存析构了，父类的内存也释放了，就不会产生内存泄露。
注：
1.析构函数其实是一个函数，不论子类还是父类，虽然可能看起来名字不一样。而且析构函数执行过程都是执行子类再到父类。
2.多态的时候一定要将析构函数写成虚函数，防止内存泄露，各个子类维护自己内部数据释放。

virtual 是实现多态的基础
它使得具体的函数跳转从编译时推迟到运行时然而构造函数的调用是编译器期间就决定的，因此它不能为虚

1.虚函数与纯虚函数 在他们的子类中都可以被重写。它们的区别是：
（1）纯虚函数只有定义，没有实现；而虚函数既有定义，也有实现的代码。
（2）包含纯虚函数的类不能定义其对象，而包含虚函数的则可以。
2. 虚函数的引入主要是为了实现多态，这部分内容是c++的精髓。
 

 

在面向对象的C++语言中，虚函数（virtual function）是一个非常重要的概念。因为它充分体现了面向对象思想中的继承和多态性这两大特性，在C++语言里应用极广。比如在微软的MFC类库中，你会发现很多函数都有virtual关键字，也就是说，它们都是虚函数。难怪有人甚至称虚函数是C++语言的精髓。 

那么，什么是虚函数呢，我们先来看看微软的解释： 

虚函数是指一个类中你希望重载的成员函数，当你用一个基类指针或引用指向一个继承类对象的时候，你调用一个虚函数，实际调用的是继承类的版本。 

——摘自MSDN 

这个定义说得不是很明白。MSDN中还给出了一个例子，但是它的例子也并不能很好的说明问题。我们自己编写这样一个例子： 

＃i nclude "stdio.h" 

＃i nclude "conio.h" 



class Parent 

{ 

public: 

char data[20]; 

void Function1(); 

virtual void Function2(); // 这里声明Function2是虚函数 

}parent; 

void Parent::Function1() 

{ 

printf("This is parent,function1\n"); 

} 

void Parent::Function2() 

{ 

printf("This is parent,function2\n"); 

} 

class Child:public Parent 

{ 

void Function1(); 

void Function2(); 

} child; 

void Child::Function1() 

{ 

printf("This is child,function1\n"); 

} 

void Child::Function2() 

{ 

printf("This is child,function2\n"); 

} 

int main(int argc, char* argv[]) 

{ 

Parent *p; // 定义一个基类指针 

if(_getch()=='c') // 如果输入一个小写字母c 

p=&child; // 指向继承类对象 

else 

p=&parent; // 否则指向基类对象 

p->Function1(); // 这里在编译时会直接给出Parent::Function1()的 

入口地址。 

p->Function2(); // 注意这里，执行的是哪一个Function2？ 

return 0; 

} 

用任意版本的Visual C++或Borland C++编译并运行，输入一个小写字母c，得到下面的结果： 

This is parent,function1 

This is child,function2 

为什么会有第一行的结果呢？因为我们是用一个Parent类的指针调用函数Fuction1()，虽然实际上这个指针指向的是Child类的对象，但编译器无法知道这一事实（直到运行的时候，程序才可以根据用户的输入判断出指针指向的对象），它只能按照调用Parent类的函数来理解并编译，所以我们看到了第一行的结果。 

那么第二行的结果又是怎么回事呢？我们注意到，Function2()函数在基类中被virtual关键字修饰，也就是说，它是一个虚函数。虚函数最关键的特点是“动态联编”，它可以在运行时判断指针指向的对象，并自动调用相应的函数。如果我们在运行上面的程序时任意输入一个非c的字符，结果如下： 

This is parent,function1 

This is parent,function2 

请注意看第二行，它的结果出现了变化。程序中仅仅调用了一个Function2()函数，却可以根据用户的输入自动决定到底调用基类中的Function2还是继承类中的Function2，这就是虚函数的作用。我们知道，在MFC中，很多类都是需要你继承的，它们的成员函数很多都要重载，比如编写MFC应用程序最常用的CView::OnDraw(CDC*)函数，就必须重载使用。把它定义为虚函数（实际上，在MFC中OnDraw不仅是虚函数，还是纯虚函数），可以保证时刻调用的是用户自己编写的OnDraw。虚函数的重要用途在这里可见一斑。