C++|多态性与虚函数（2）|虚析构函数|重载函数|纯虚函数|抽象类

前言

看这篇之前，可以先看多态性与虚函数（1）⬇️

C++|多态性与虚函数（1）功能绑定|向上转换类型|虚函数-CSDN博客https://blog.csdn.net/weixin_74197067/article/details/138861418?spm=1001.2014.3001.5501这篇文章会接着上一篇来记录

虚析构函数

构造函数不能是虚函数，但析构函数可以是虚函数，同样的在析构函数前面加上virtual就 称该析构函数为虚析构函数，语法如下：

virtual ~类名（） 

{

        函数体

}

#include<iostream>
using namespace std;

class point
{
public:
	point():x(0),y(0){}
	point(double a, double b) :x(a), y(b) {}
	virtual ~point()
	{
		cout << "~point" << endl;
	}

	double x;
	double y;

};

class rectangle :public point
{
public:
	rectangle():point(0,0),x1(0),y1(0){}
	rectangle(double a, double b, double c, double d) :point(a, b), x1(c), y1(d) {}
	~rectangle()
	{
		cout << "~rectangle" << endl;
	}
private:
	double x1;
	double y1;
};

int main()
{
	point* p = nullptr;
	p = new rectangle;
	delete p;
	return 0;
}

就会先调用rectangle 的析构函数，在调用point的析构函数。如果在基类的析构函数中不加virtual，那么运行结果只会调用point的析构函数。

如果将基类的虚构函数写为虚函数，那么后面所有继承该基类的派生类的所有析构函数自动成为虚函数，即使名字不相同。

当基类的析构函数为虚函数时，无论指针指向的是同一类族那个类的对象，程序都会动态关联，调用相应的析构函数，对该对象所涉及的额外内存空间进行清理工作。

最好把基类的析构函数声明为虚函数，这使得后面派生类所有的析构函数均为虚函数，这样如果调用delete运算符准备删除一个对象，而delete运算符的操作对象用了派生类对象的基类指针，系统就会先调用派生类的析构函数，在调用基类的析构函数，这样整个派生类的对象被完全释放。

虚函数与重载函数比较

函数重载处理的是同一层次的函数重名问题，

而虚函数处理的是同一类族中不同派生层次 上的函数重名问题

函数重载时，参数个数和参数类别可以不一样

虚函数必须保证同名，同参数，同返回值

函数重载可以是成员函数也可以普通函数

虚函数只能是成员函数

函数重载的调用是以所传递参数序列的差别作为调用不同函数的依据

虚函数是根据对象的不同去调用不同类的虚函数

函数重载在编译时表现出多态性

虚函数在运行时表现多态性

纯虚函数

有时，基类往往表示一种抽象的概念，并不与其他事物相连，例如，封闭图形只是一个概念，但他可以派生出，三角形、四边形、五边形...

纯虚函数与一般虚函数定义格式基本相同，只是在后面多了”=0“部分表示没有函数体部分，纯虚函数的函数体由派生类给出。

纯虚函数的定义形式如下：

class 类名

{

        ...

        virtual 函数类型 函数名（参数表）=0；

        ...

}

下面演示一下：基类是封闭图形，派生类有三角形，四边形。

代码如下所示：

#include<iostream>
using namespace std;
class shape
{
public:
	virtual void show() = 0;
};

class triangle :public shape
{
public:

	triangle(double a,double b,double c):a(a),b(b),c(c){}
	void show()
	{
		cout << "triangle" << endl;
	}
private:
	double a;
	double b;
	double c;

};

class quadrangle :public shape
{
public:
	quadrangle(double a,double b,double c,double d):a(a),b(b),c(c),d(d){}
	void show()
	{
		cout << "quardrangle" << endl;
	}
private:
	double a;
	double b;
	double c;
	double d;
};

int main()
{
	shape *s=nullptr;
	triangle t(1, 2, 3);
	quadrangle q(1, 2, 3, 4);
	s = &t;
	s->show();

	s = &q;
	s->show();
	return 0;
}

抽象类

如果一个类至少有一个纯虚函数，那么就称该类为抽象类，因此上面那个shape类就是抽象类。

对于抽象类的使用规则：

1.因为抽象类 中至少包含一个没有定义功能的纯虚函数，抽象类只能作为其他类的基类的来使用，不能建立抽象类对象，只能为派生类提供一个接口规范，其功能由派生类给出。

2.不允许从具体类中派生出抽象类

3.抽象类不能用作参数类型，函数返回值类型或者显示转换类型

4.可以声明抽象类类型的指针和引用，此指针可以指向它的派生类对象进而实现动态多态性

5.如果这个派生类没有重写虚函数，那么这个 派生类就是简单继承这个纯虚函数，那么这个派生类就是一个抽象类

6.在抽象类中可以定义普通成员函数或者虚函数

注意函数体为空的虚函数不是纯虚函数，函数体为空不代表没有函数体，纯虚函数没有函数体

override

如果一个成员函数是虚函数，那么在后续派生类里的同名函数都是虚函数，无须再用virtual修饰。这样就会出现以下问题：

1.这样在函数很多的情况下，就难以分辨哪些函数是派生类特有的成员函数，哪些函数继承自基类；

2.还有可能派生类可能无意使用了一个同名但函数原型不同的函数”覆盖“了基类的虚函数。

#include<iostream>
using namespace std;
class base
{
public:
	virtual void f() = 0;//纯虚函数
	virtual void g()const//虚函数
	{
		cout << "base:g()" << endl;
	}
	 void h()//一般成员函数
	{
		cout << "base:h()" << endl;
	}
};

class derived :public base
{
public:
	 void f()//纯虚函数重写
	{
		cout << "derived:f()" << endl;
	}
	 void g()//不是虚函数重新，遗漏了const修饰
	{
		cout << "derived:g()" << endl;
	}
	 void h()//一般成员函数
	{
		cout << "derived:h()" << endl;
	}
};


int main()
{
	base* b = nullptr;
	derived c;
	b = &c;
	b->f();
	b->g();
	b->h();
	return 0;
}

C++11增加了一个特殊的标识符override,它可以显示地标记虚函数重写 ，明确代码编写者的意图：派生类成员函数名后面有override修饰，那么这个函数就一定是虚函数，而且函数原型也必须与基类声明一致，否则编译错误。

void f()override//纯虚函数重写
{
	cout << "derived:f()" << endl;
}

final

final可以在类名后面使用，显式的禁止类被继承，不能再有派生类

final可以在虚函数后面使用，显式的禁止该函数在派生类中再次被重写

例如

#include<iostream>
using namespace std;

class base
{
public:
	virtual void f() = 0;//纯虚函数
	virtual void g()//虚函数
	{
		cout << "base:g()" << endl;
	}
};

class derived :public base
{
public:
	void f()override final//纯虚函数重写,并不允许被重写
	{
		cout << "derived:f()" << endl;
	}
	void g()override//虚函数重写
	{
		cout << "derived:g()" << endl;
	}

};

class last final :public derived//表示last不允许被继承，last也不会再有派生类
{
	/*void f()override //纯虚函数重写,并不允许被重写
	{cout << "last:f()" << endl;}*/
	void g()//虚函数重写
	{
		cout << "last:g()" << endl;//可以重写
	}
};

 

last类在类名后使用了final，使它变成了类体系的终点

在derived类的函数f后使用了final,表示在后面的派生类中禁止重写该虚函数。