C++中虚函数的使用

虚函数的定义

在某基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数，用法格式为：virtual 函数返回类型 函数名（参数表） {函数体}；实现多态性，通过指向派生类的基类指针或引用，访问派生类中同名覆盖成员函数。

虚函数的使用

让我们以下面一道题目为例，探索虚函数的使用方法。

题目：定义一个车(vehiele)基类，有Run、Stop等成员函数，由此派生出自行车(bicycle)类、汽车(motorcar)类，从bicycle和motorcar派生出摩托车(motorcycle)类，它们都有Run、Stop等成员函数。观察虚函数的作用。

步骤：编写程序定义一个车(vehicle)基类，有Run、Stop等成员函数，由此派生出自行车(bicycle)类、汽车(motorcar)类，从bicycle和motorcar派生出摩托车(motorcycle)类，它们都有Run、Stop等成员函数。在main()函数中定义vehicle、bicycle、motorcar、motorcycle的对象，调用其Run()、Stop()函数，观察其执行情况。再分别用vehicle类型的指针来调用这几个对象的成员函数，看看能否成功；把Run、Stop定义为虚函数，再试试看。

第一步：不使用虚函数，直接调用函数

代码如下：

#include<iostream>
using namespace std;

class vehicle
{
protected:
	int weight;
public:
	vehicle(int wt = 0) { weight = wt;}
	~vehicle() {}
	void Run() { cout << "Vehicle run." << endl; }
	void Stop() { cout << "Vehicle stop." << endl; }
};

class bicycle :public virtual vehicle
{
public:
	bicycle(int wt = 0) { weight = wt;}
	~bicycle() { }
	void Run() { cout << "Bicycle run." << endl; }
	void Stop() { cout << "Bicycle stop." << endl; }
};

class motocar :public virtual vehicle
{
public:
	motocar(int wt = 0) { weight = wt;}
	~motocar() {}
	void Run() { cout << "Motocar run." << endl; }
	void Stop() { cout << "Motocar stop." << endl; }
};

class motobicycle :public bicycle, public motocar
{
public:
	motobicycle(int wt = 0) { weight = wt; }
	~motobicycle() {}
	void Run() { cout << "Motobicycle run." << endl; }
	void Stop() { cout << "Motobicycle stop." << endl; }
};

int main()
{
	vehicle v(100);
	v.Run();
	v.Stop();
	bicycle b(5);
	b.Run();
	b.Stop();
	motocar c(80);
	c.Run();
	c.Stop();
	motobicycle a(10);
	a.Run();
	a.Stop();
}

运行结果：

结论：
此种方法能正常调用各基类、派生类（包括多基类派生）中的函数。

第二步：不使用虚函数，使用vehicle类指针进行各函数的调用
代码如下：
注：类声明与第一步相同，故不再重复，下面只列出变化后的主函数。

int main()
{
	vehicle* p;
	vehicle v(100);
	p = &v;
	p->Run();
	p->Stop();
	bicycle b(5);
	p = &b;
	p->Run();
	p->Stop();
	motocar c(80);
	p = &c;
	p->Run();
	p->Stop();
	motobicycle a(10);
	p = &a;
	p->Run();
	p->Stop();
}

运行结果：

结论：
由于所设指针p为vehicle类指针，所以只能调用vehicle类中的函数。

第三步：使用虚函数，并直接调用函数
代码如下：
注：主函数与第一步相同，故不再重复，下面只列出变化后的类声明。

class vehicle
{
protected:
	int weight;
public:
	vehicle(int wt = 0) { weight = wt;}
	~vehicle() {}
	void virtual Run() { cout << "Vehicle run." << endl; }
	void virtual Stop() { cout << "Vehicle stop." << endl; }
};

class bicycle :public virtual vehicle
{
public:
	bicycle(int wt = 0) { weight = wt;}
	~bicycle() { }
	void virtual Run() { cout << "Bicycle run." << endl; }
	void virtual Stop() { cout << "Bicycle stop." << endl; }
};

class motocar :public virtual vehicle
{
public:
	motocar(int wt = 0) { weight = wt;}
	~motocar() {}
	void virtual Run() { cout << "Motocar run." << endl; }
	void virtual Stop() { cout << "Motocar stop." << endl; }
};

class motobicycle :public bicycle, public motocar
{
public:
	motobicycle(int wt = 0) { weight = wt; }
	~motobicycle() {}
	void virtual Run() { cout << "Motobicycle run." << endl; }
	void virtual Stop() { cout << "Motobicycle stop." << endl; }
};

运行结果：

结论：
使用虚函数并且直接调用，能正常调用各基类、派生类（包括多基类派生）中的函数。

第四步：使用虚函数，使用vehicle类指针进行函数调用
代码如下：
注：类声明与第三步相同，主函数与第二步相同，故不再重复代码。

运行结果：

结论：
1.使用虚函数后，使用vehicle类指针p可以对其他派生类中重新定义的函数进行正常调用。
2.虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。

结论

虚函数的作用：实现多态性

如果在基类中没有将Run()声明为虚的，则p->Run()将根据指针类型（vehicle *)调用vehicle::Run()。指针类型在编译时已知，因此编译器在编译时，可以将Run()关联到vehicle::Run()。总之，编译器对非虚方法使用静态联编。
然而，如果将基类中将Run()声明为虚的，则p->Run()根据对象类型（vehicle）调用vehicle::Run()。在这个例子中，对象类型为vehicle，但通常只有在运行程序时才能确定对象的类型。所以编译器生成的代码将在程序执行时，根据对象类型将Run()关联到vehicle::Run()、bicycle::Run()、motocar::Run()或motobicycle::Run()。总之，编译器对虚方法使用动态联编。

注意:
在大多数情况下，动态联编很好，因为它让程序能够选择为特定类型设计的方法。

但效率问题：为使程序能够在运行阶段进行决策，必须采用一些方法来跟踪基类指针或引用指向的对象类型，这增加了额外的处理开销。例如，如果类不会用作基类，则不需要动态联编。同样，如果派生类不重新定义基类的任何方法，也不需要太动态联编。在这些情况下，使用静态联编更合理，效率也更高。由于静态联编的效率更高，因此被设置为C++的默认选择。

有关虚函数的注意事项

1.在基类方法的声明中使用关键字virtual可使该方法在基类以及所有的派生类（包括从派生类派生出来的类）中是虚的。
2.如果使用指向对象的引用或指针来调用虚方法，程序将使用为对象类型定义的方法，而不使用为引用或指针类型定义的方法。这称为动态联编或晚期联编。这种行为非常重要，因为这样基类指针或引用可以指向派生类对象。
3.如果定义的类将被用作基类，则应将那些要在派生类中重新定义的类方法声明为虚的。