C++的虚函数和虚析构函数

疑问：

如何利用一个循环结构，依次处理同一个类族中不同类的对象？

如何解决这个问题呢？这就要应用到虚函数来实现多态性。

虚函数是动态绑定的基础，必须是非静态的成员函数。虚函数经过派生之后，在类族中就可以实现运行过程中的多态。

根据赋值兼容规则，可以使用派生类对象来代替基类对象。如果用基类类型的指针指向派生类对象，就可以通过这个指针访问该对象，但访问到的，仅仅是从基类集成来的同名成员。

解决这一问题的办法：如果需要通过基类的指针指向派生类的对象，并访问某个与基类同名的成员，那么首先在基类中将这个同名函数声明为虚函数。

这样，通过基类类型的指针，就可以使属于不同派生类的不同对象产生不同的行为（操作），从而实现运行过程中的多态。

一般虚函数成员

声明语法：virtual 函数类型  函数名（形参表）

其实就是在类的定义中使用virtual关键字来限定成员函数，虚函数只能出现在类定义中的函数原型声明中，而不能在成员函数实现的时候。

运行过程中的多态需要满足三个条件：

1、满足赋值兼容规则。

2、声明虚函数。

3、由成员函数来调用或者是通过指针、引用来访问虚函数。

如果使用对象名来访问虚函数，则绑定在编译过程中就可以进行（静态绑定），无需在运行过程中进行。

注意：虚函数一般不能声明为内联函数，因为虚函数的调用时需要动态绑定的，而对内联函数的处理是静态的，所以虚函数一般不声明为内联函数（语法上是没有问题的）。

[b]实例：[/b]

#include <iostream>
#include <conio.h>
using namespace std;

class Base  	//基类
{
public:
virtual void display()const;	//虚函数
};
void Base::display()const
{
cout<<"Base::display()"<<endl;
}

class Base1 :public Base	//派生类
{
public:
void display()const;
};
void Base1::display()const
{
cout<<"Base1::display()"<<endl;
}

class Base2 : public Base	//派生类
{
public:
void display()const;
};
void Base2::display()const
{
cout<<"Base2::display()"<<endl;
};

void fun(Base *ptr)
{
ptr->display();
}

int main()
{
Base base;
Base1 base1;
Base2 base2;

fun(&base);
fun(&base1);
fun(&base2);

return 0;
}

[b]运行结果：[/b]



结果分析：
程序中的Base1和Base2、Base属于同一个类族，而且是通过共有派生而来的，因此满足赋值兼容规则。

同时，基类Base的成员函数display()声明为虚函数，程序中使用对象指针来访问函数成员。

这样绑定过程就是在运行中完成的，实现了运行中的多态。

通过基类类型的指针留可以访问正在指向的对象的成员，这样就能够对同一类族中的对象进行同一的处理，抽象程度更高，程序更加简洁、高效。

系统如何判断派生类的一个函数成员是不是虚函数呢？主要有以下方法：
1、该函数是否与基类的虚函数由相同的名称。

2、该函数是否与基类的虚函数有相同的参数个数和相同的对应参数类型。

3、该函数是否与基类的虚函数有相同的返回值或者满足赋值兼容规则的指针、引用型的返回值。

如果从名称、参数、返回值这三个方面检查之后，派生类满足上述条件，就会自动确定为虚函数。这时，派生类的虚函数便会自动覆盖基类的虚函数。

同时，派生类的虚函数还会隐藏基类中同名函数的所用其他重载形式。

注意：基类中声明的非虚函数，通常是代表那些不希望被派生类改变的功能，也是不能实现多态的。所以一般不要重写继承来的非虚函数（语法上是没有限制的），

因为这样就会导致通过基类指针和派生类的指针或者对象调用同名函数时，产生不同的结果，引起混乱。

虚析构函数

在C++中，不能声明虚构造函数，在可以声明虚析构函数。

声明方法：virtual ~类名（）；

当析构函数设置为虚函数之后，在使用指针引用时可以动态绑定，实现运行时多态。

保证使用基类类型的指针就能够调用适当的析构函数针对不同的对象进行清理工作。

一句话：如果有可能通过基类指针调用对象的析构函数，就需要让基类的析构函数称为虚函数，不然会产生不确定的后果。

实例：
下面通过一个实例来说明。

#include <iostream>
#include <conio.h>
using namespace std;

class Base  	//基类
{
public:
~Base();	//虚函数
};
Base::~Base()
{
cout<<"Base 析构函数"<<endl;
}

class Derived :public Base	//派生类
{
public:
Derived();
~Derived();
private:
int *p;
};
Derived::Derived()
{
p = new int(0);
}

Derived::~Derived()
{
cout<<"Derived 析构函数"<<endl;
delete p;
}

void fun(Base *b)
{
delete b;
}

int main()
{
Base *b = new Derived();
fun(b);
return 0;
}

运行结果：



结果分析：
从上面的例子可以看出，通过基类指针，删除派生类对象时，调用的是基类的析构函数，派生类的析构函数并没有被执行，

所以派生类对象中动态分配的内存空间也是没有被释放的，这就造成了内存泄漏。这是非常危险的。

解决办法：
为了避免上述错误，可以将析构函数声明为虚函数。程序修改如下：

class Base  	//基类
{
public:
virtual ~Base();	//虚函数
};

运行结果：



从结果可以看出，此时对象所占用的内存才彻底的清楚干净了。派生类中动态申请的内存被正确的释放了。