C++总结之虚函数的作用（20160805）

虚函数的作用

多态性是面向对象程序设计的一个重要特征。顾名思义，多态性就是一个事物具有多种形态。在面向对象方法中一般是这样表述多态性的：向不同的对象发送同一个消息，

不同的对象在接收时会产生不同的行为。也就是说，每个对象可以用自己的方式去响应共同的消息，所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函

数。
在C++中，多态性表现形式之一是：具有不同功能的函数可以用同一个函数名，这样就可以实现用一个函数名调用不同内容的函数。从系统实现的角度来看，多态性分为两

类：静态多态性和动态多态性。静态多态性是通过函数重载实现。由函数重载和运算符重载（运算符重载实质上也是函数重载）形成的多态性属于静态多态性，要求程序在编译

时就知道函数调用的全部信息，因此，在程序编译时系统就能决定要调用的是哪个函数。静态多态性的函数调用速度快、效率高，但是缺乏灵活性，在程序运行之前就已经决定

了执行的函数和方法。动态多态性是通过虚函数实现的。特点是：不在编译时确定调用的哪个函数，而是在程序运行过程中动态地确定操作所针对的对象。这里先介绍动态多态

性，静态多态性以后再介绍。

1    虚函数的作用

在同一个类中是不能定义两个名字相同、参数个数和类型都相同的函数的，否则就是“重复定义”。但在类的继承层次结构中，在不同的层次中可以出现名字相同、参数个数和类

型都相同而功能不同的函数，这种情况是合法的，因为它们不在同一个类中，编译系统按照同名覆盖的原则决定调用的对象。那么，能否用同一个调用形式来调用派生类和基类

的同名函数。在程序中不是通过不同的对象名去调用不同派生层次中的同名函数，而是通过指针来调用，要做的只是在调用前临时给指针变量赋予不同的值（使之指向不同的类

对象）。C++中的虚函数就是用来解决动态多态问题的。所谓虚函数，就是在基类声明函数时虚拟的，并不是实际存在的函数，然后在派生类中才正式定义此函数。在程序运行

期间，用指针指向某一派生类对象，这样就能调用指针指向的派生类对象中的函数，而不会调用其他派生类中的函数。虚函数的作用是允许在派生类中重新定义与基类同名的函

数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。

using namespace std;
class Student
	{
	public:
		Student()
		{

		}
		~Student()
		{

		}
		Student(int num, std::string name, float score) :m_num(num), m_name(name), m_score(score)
		{

		}
		 void display()            //输出数据成员 num name score 
		{
			cout << "num = " << m_num << "; name = "<< m_name.c_str() << "; score = "<< m_score << std::endl;
		}
	protected:
			 int m_num;
			 string m_name;
			 float m_score;
			 };
 class Graduate : public Student
 {
public:
	Graduate(int num, std::string name, float score, float wage) :m_wage(wage)
	{
		m_num = num;
		m_name = name;
		m_score = score;
	}
	~Graduate()
	{

	}
	void display()             //输出成员函数 num name score wage 
	{
		cout << "num = " << m_num << "; name = " << m_name.c_str() << "; score = " << m_score << "; wage = "<<m_wage<< std::endl;
	}
private:
		 float m_wage;
};

 int main()
 {
		Student stud(1001, "Li", 87.5);           //定义基类对象
		Graduate grad(2001, "Wang", 98.5, 1200); //定义派生类对象
		Student* pt = &stud;                           //定义基类指针变量，指向stud
		pt->display();<span style="white-space:pre">	
		pt = &grad;                                   //基类指针变量指向派生类对象grad
		pt->display();	
		return 0;
 }

运行结果如下：

我们本希望输出grad的全部数据成员，但结果却不是这样，这是因为：本来，基类指针是用来指向基类对象的，如果用它指向派生类对象，则自动进行指针类型转换，将派

生类对象的指针先转换为基类的指针，这样基类指针指向的是派生类中基类部分，所以只输出从基类继承过来的数据成员。Ofcourse，想要输出grad1的全部数据成员，可以通

过对象名或指向派生类对象的指针变量来调用display() 。但是，如果该基类有多个派生类，每个派生类又产生新的派生类，每个派生类都有同名函数display，若在程序中需要

调用不同类的同名函数，则上述方法就很不方便。用虚函数就能解决这个问题。只需对原程序作一点修改，在Student类中声明display函数时，在最前面加一个关键字virtual：
1: virtual void display() ;
这样就把Student类的display函数声明为虚函数.其余部分不变，这次的运行结果是：

2    在什么情况下应当声明虚函数
在使用虚函数时，有两点需要注意：
（1）只能用virtual声明类的成员函数，把它作为虚函数，而不能将类外的普通函数声明为虚函数。
（2）一个成员函数被声明为虚函数后，在同一类族中的类就不能在定义一个非virtual的但与该虚函数具有相同的参数和函数返回值类型的同名函数。是否应该把一个成员函数声明为虚函数，主要考虑以下几点：
   a、首先看成员函数所在的类是否会作为基类。然后看成员函数在类的继承后功能是否会改变，如果希望更改其功能，一般应该将它声明为虚函数。
   b、 如果成员函数在类被继承后功能无须更改，或派生类用用不到该函数，则不要把它声明为虚函数。
   c、应考虑对成员函数的调用是通过对象名还是通过基类指针或引用去访问，如果是通过基类指针或引用去访问，则应当声明为虚函数。
   d、有时，在定义虚函数时，并不定义其函数体，即函数体为空。它的作用只是定义了一个虚函数名，具体功能留给派生类去添加。
3    虚析构函数
析构函数的作用是在对象撤销之前做必要的“清理现场”的工作。当派生类类的对象从内存中撤销时一般先调用派生类的析构函数，然后再调用基类的析构函数。
但是，如果用一个基类指针指向一个用new建立的派生类的临时对象，在程序中用delete运算符撤销该对象时，会发生这样一种情况：系统只会执行基类的析构函数，而不会执行派生类的析构函数。
例如：

using namespace std;
 class Point								//定义基类Point类
 {
public:
		Point(){}							//Point类的构造函数
		~Point()
		{								//Point类的析构函数
			cout << " executing Point destructor " << endl;
		}
};

class Circle : public Point					//定义派生类Circle类
{
public:
		Circle(){}							//Circle类的构造函数
		~Circle()							//派生类的析构函数
		{
			cout << " executing Circle destructor " << endl;
		 }
 };

int main()
{
	 Point* p = new Circle;					//用new开辟动态存储空间
	 delete p;						//用delete释放动态存储空间
	 return 0;
}

在本程序中，p是指向基类的指针变量，指向用new开辟的动态存储空间，希望用delete释放p所指向的空间。但运行结果为：

运行后内存未完全释放，如下图所示

表示只执行了基类Point的析构函数，而没有执行派生类的构造函数。如果希望执行派生类Circle的析构函数，可以将基类的析构函数声明为虚函数，如下：
 virtual ~Point()
 {
       cout << " executing Point destructor "  << endl ;
 }
则执行结果为：

运行后内存完全释放

先调用了派生类的析构函数，再调用基类的析构函数。即当基类的析构函数为虚函数时，无论指针指的是同一类族中的哪一个类对象，系统都会采用动态关联，调用相应的析构函数，对该对象进行清理工作。
如果将基类的析构函数声明为虚函数时，由该基类所派生的所有派生类的析构函数都自动成为虚函数，即使派生类的析构函数与基类的析构函数的名字不相同。最好把基类的析构函数声明为虚函数。
这样将使所有派生类的析构函数自动成为虚函数。这样，如果在程序中显示的调用了delete运算符准备删除一个对象，则系统会调用相应类的析构函数。这样造成内存泄漏。