C++ 学习记录 类的多态性与虚函数实例

1.虚函数

虚函数是一种动态的重载方式。虚函数的作用是允许在派生类中重新定义与基类同名的函数，并可以通过基类指针或引用来访问基类和派生类中同名函数。

C++ 中要声明一个成员函数为虚函数，只需要在函数的声明前加上一个关键字 virtual 即可，然后就像对待普通成员函数那样，给它加上定义。

实例

设计人类、英语学生类和复读机类三个类，具体要求如下：

1.人类（ Chinese ）
它有一个虚函数 greet，函数输出中文问候，即你好。

2.英语学生类（ EnglishLearner ）
继承 Chinese 类，重写 greet 函数，访问性为 public，输出英文问候，即Hello。

3.复读机类（ Repeater ）
继承 Chinese 类，以 public 访问性重写 greet 函数，函数调用 Chinese 类的 greet 函数。

#include <iostream>
using namespace std;

class Chinese
{
    public:
    	virtual void greet()
    	{
    		cout<<"你好"<<endl;
		}   
};
//人类的定义

class EnglishLearner : public Chinese
{
    public:
    	virtual void greet()
    	{
    		cout<<"Hello"<<endl;
		}
};
//英语学生类的定义

class Repeater : public Chinese
{
    public:
    	virtual void greet()
    	{
    		Chinese::greet();//调用Chinese的greet函数要加类名限制符
		}
    
    
};
//复读机类的定义

int main()
{
    Chinese ce;
    EnglishLearner le;
    Repeater re;
    ce.greet();
    le.greet();
    re.greet();
}

重名函数都加 virtual 限定为虚函数解决重名问题

2.虚析构函数

如果一个父类的析构函数没有声明成虚函数，那么使用 delete 运算符 销毁一个父类指针所指的子类对象时，就只会调用父类的析构函数，子类的析构函数则不会被调用，这样就可能导致子类动态分配的资源无法及时回收，造成资源泄露。

如果将析构函数声明为虚函数，调用它时除了调用子类重写的那个版本，还会沿着继承链向上（父类方向）依次调用父类的析构函数。

实例

设计三个复读机类和一个普通函数，具体要求如下：

1.复读机类（ Repeater ）
它有一个成员函数 Play，在这里它什么也不做。它还有一个析构函数，它被调用时会输出一行砰！。

2.正向复读机类（ ForRepeater ）
继承 Repeater 类并重写 Play 函数，输出没想到你也是一个复读机且在析构函数中输出正·复读机 炸了。

3.反向复读机类（ RevRepeater ）
继承 Repeater 类也重写 Play 函数，输出机读复个一是也你到想没且在析构函数中输出机读复·反 炸了。

4.普通函数：Repeater* CreateRepeater(int type)，函数根据 type 的值，动态创建不同的复读机对象，并返回它的指针。其中当type = 0，创建 ForRepeater 对象；type = 1，创建 RevRepeater 对象；其他则返回 0。

#include <iostream>
using namespace std;

class Repeater
{
	public:
		virtual void Play(){}
	    virtual ~Repeater()
	    {
	    	cout<<"砰！"<<endl;
		}
};
//复读机基类的定义

class ForRepeater : public Repeater
{
	public:
    	virtual void Play()
		{
			cout<<"没想到你也是一个复读机"<<endl;
		}
		virtual ~ForRepeater()
		{
		   	cout<<"正·复读机 炸了"<<endl;
		}
};
//正向复读机的定义

class RevRepeater : public Repeater
{
	public:
		virtual void Play()
		{
			cout<<"机读复个一是也你到想没"<<endl;
		}
    	virtual ~RevRepeater()
		{
		   	cout<<"机读复·反 炸了"<<endl;
		}
};
//反向复读机的定义

Repeater* CreateRepeater(int type)
{
    if(type==0)
    {
    	Repeater *p=new ForRepeater();
    	return p;
	}
	else
	{
		Repeater *p=new RevRepeater();
    	return p;
	}
}
//普通函数
//注意这里，子类的对象可以把地址给基类的指针，返回类型都是基类的指针
//注意动态创建的方法

int main()
{
	int i;
	cin >> i;
    Repeater *ptr = CreateRepeater(i);
    ptr->Play();
    delete ptr;
}

3.纯虚函数和抽象类

纯虚函数

有时在类中将某一成员声明为虚函数，并不是因为基类本身的要求，而是因为派生类的需求，在基类中预留一个函数名，具体功能留给派生类区定义。这种情况下就可以将这个纯虚函数声明为纯虚函数。即纯虚函数的作用是在基类中为其派生类保留一个函数的名字，以便派生类对它进行定义

声明方式：virtual 函数类型 函数名（参数列表） = 0

抽象类

含有纯虚函数的类就成为抽象类。抽象类只是一种基本的数据类型，用户需要在这个基础上根据自己的需要定义处各种功能的派生类。

抽象类的作用就是为一个类族提供一个公共接口。抽象类不能定义对象，但是可以定义指向抽象类的指针变量，通过这个指针变量可以实现多态。

实例

设计图像基类、矩形类和圆形类三个类，函数成员变量据情况自己拟定，其他要求如下：

1.图形类（ shape ）
纯虚函数：void PrintArea()，用于输出当前图形的面积。

2.矩形类（ Rectangle ）
继承 Shape 类，并且重写 PrintArea 函数，输出矩形的面积，输出格式为：矩形面积 = width*height。
带参构造函数：Rectangle(float w,float h)，这两个参数分别赋值给成员变量的宽、高。

3.圆形类（ Circle ）
继承 Shape 类，并且重写 PrintArea 函数，输出圆形的面积，输出格式为：圆形面积 = radio * radio * 3.14。
带参构造函数：Circle(float r)，参数 r 代表圆的半径。

#include <iostream>
using namespace std;

class Shape
{
	public:
    	virtual void PrintArea() = 0; 
};//基类定义

class Rectangle : public Shape
{
	public:
		float w,h;
    	Rectangle(float w,float h)
    	{
    		this->w=w;
    		this->h=h;
		}
		
		virtual void PrintArea()
		{
			cout<<"矩形面积 = "<<w*h<<endl;
		} 
};//矩形类的定义




class Circle : public Shape
{
	public:
		float r;
   		Circle(float r)
   		{
    		this->r = r;
		}
		
		virtual void PrintArea()
		{
			cout<<"圆形面积 = "<<r*r*3.14<<endl;
		}   
};
//圆形类的定义


int main()
{
	int i,j;
	cin >> i >> j;
    Shape *ptr = new Rectangle(i,j);//父类的指针可以指向子类的对象
    ptr->PrintArea();
    delete ptr;

    ptr = new Circle(i);
    ptr->PrintArea();
    delete ptr;
}