多态性与虚函数（c++)

-VE-

于 2024-09-05 16:10:28 发布

阅读量837

点赞数 27

文章标签： c++

本文链接：https://blog.csdn.net/Water_VE/article/details/141870128

版权

1.概念解释

在c++程序设计中，多态性是指具有不同功能的函数可以是同一个函数名。所以函数重载跟运算符重载都是函数的多态性的体现。

其实多态性在生活中也有体现，比如说校长发布说明天要开学了，对于这么同一个消息，学生要补作业，老师要备课，家长要早起做饭...。

从系统实现的叫角度来看，多态性分为静态多态性和动态多态性。静态多态性是在程序编译时就能决定调用哪一个的，有被称为编译时的多态性。静态多态性就是通过函数重载实现的。动态多态性是在程序运行过程中才动态地确定操作所针对的对象。又被称为运行时多态性。动态多态性是通过虚函数实现的。

2.对于静态多态性的回顾

来看一段代码：

#include<iostream>
using namespace std;
class point//这是点类
{
protected:
	int _x;
	int _y;
public:
	point(int x=0 , int y=0 )
	{
		_x = x;
		_y = y;
	}
	friend ostream& operator<<(ostream& output, const point& p)
	{
		output <<"圆心:" << p._x << ',' << p._y << endl;
		return output;
	}
};
class circle :public point//这是圆类
{
protected:
	int _r;
public:
	circle(int x=0,int y=0,int r=0):point(x,y)
	{
		_r = r;
	}
	float area()
	{	
		return 3.14 * _r * _r;
	}
	friend ostream& operator<<(ostream& output,const circle& c)
	{
		output << "圆心:" <<c._x << ','<<c._y <<"半径" << c._r << endl;//这个是操作符重载函数，跟上面一个类的函数构成函数重载
		return output;
	}
};
class cylinder:public circle//这是圆柱类
{
protected:
	int _h;
public:
	cylinder(int x = 0, int y = 0, int r = 0, int h = 0) :circle(x, y, r)
	{
		_h = h;
	}
	float volume()
	{
		return 3.14 * _r * _r * _h;
	}
	float area()//注意这里是跟上面的一个函数完全一样的，参数，函数名返回类型都是一样的，这个地方不是函数重载，是基类和派生类之间的同名覆盖
	{
		return (3.14 * _r * _r * 2 + 3.14 * _r * 2 * _h);
	}
	friend ostream& operator<<(ostream& output, const cylinder& ch)
	{
		output << "圆心：" << ch._x << ',' << ch._y << ' ' << "半径：" << ch._r << ' ' << "高：" << ch._h << endl;
		return output;
	}
};
int main()
{
	cylinder ch(2,2,1,3);
	point& pref = ch;//注意这里的引用：定义了point类的引用变量pref，并用派生类的cylinder对象ch来初始化。
	//派生类对象是可以代替基类对象为基类对象的引用初始化的，他就是ch基类部分的别名，与ch中的基类共享一段存储空间
	circle& cref = ch;
	cout << ch;
	cout << pref;
	cout << cref;
	cout << ch.area() << endl;
	cout << cref.area() << endl;
	return 0;
}

3.虚函数

我们已经知道在同一个类中不能同时定义两个名字相同，参数个数相同和返回类型都相同的函数，否则就是重复定义。但是在类的继承层次结构中就可以出现完全相同的函数。编译系统会按照同名覆盖的原则决定调用的对象，就像上面的例子，调用cylinder类中的area函数：ch.area（）；调用基类circle中的area函数：ch.circle::area（）;用这种方法区分两个同名函数，但是这样很不方便。

有一个想法是通过一个基类类型的指针，改变指针的指向来访问不同类的同名函数。（请看下面代码）

#include<iostream>
#include<string>
using namespace std;
class student
{
protected:
	int _num;
	string _name;
	float _score;
public:
	student(int num, string name, float score)
	{
		_num = num;
		_name = name;
		_score = score;
	}
	void display()
	{
		cout << _num << ' ' << _name << ' ' << _score << endl;
	}
};
class graduate:public student
{
protected:
	int _pay;
public:
	graduate(int num,string name,float score,int pay):student(num,name,score)
	{
		_pay = pay;
	}
	void display()
	{
		cout << _num << ' ' << _name << ' ' << _score << ' '<<_pay<<endl;
	}
};
int main()
{
	student stu(1,"zhangsan",100.0);
	graduate gra(1, "zhangsan", 100.0, 5000);
	student* p1 = &stu;
	p1->display();
	p1 = &gra;
	p1->display();
	return 0;
}

运行结果如下：

其实p1指针在改变的时候是改变了其指向的内存空间的，但是调用的还是基类的display函数。但是如果我们将student类中的display函数前面加上virtual关键字，使其变成一个虚函数就能解决这个问题：

#include<iostream>
#include<string>
using namespace std;
class student
{
protected:
	int _num;
	string _name;
	float _score;
public:
	student(int num, string name, float score)
	{
		_num = num;
		_name = name;
		_score = score;
	}
	virtual void display()
	{
		cout << _num << ' ' << _name << ' ' << _score << endl;
	}
};
class graduate:public student
{
protected:
	int _pay;
public:
	graduate(int num,string name,float score,int pay):student(num,name,score)
	{
		_pay = pay;
	}
	void display()
	{
		cout << _num << ' ' << _name << ' ' << _score << ' '<<_pay<<endl;
	}
};
int main()
{
	student stu(1,"zhangsan",100.0);
	graduate gra(1, "zhangsan", 100.0, 5000);
	student* p1 = &stu;
	p1->display();
	p1 = &gra;
	p1->display();
	return 0;
}

这就是虚函数！

说明：本来基类指针是用来指向基类对象的，如果用它来指向派生类对象,则进行指针了类型转换，将派生类类型的指针转换成基类的指针，所以原来的基类指针指向的是派生类对象的基类部分。（可见派生类中的成员跟基类成员是没有任何关系的，是不同地址的东西，可以推测存储时基类成员跟派生类成员是分开的，仅仅是我的推测，有佬直到答案可以发在评论区，让我学习一下）。

可以看到虚函数允许同名函数但是不会同名覆盖。