C++面向对象编程（七） 多态的详解

最新推荐文章于 2024-05-08 23:24:08 发布
最新推荐文章于 2024-05-08 23:24:08 发布
阅读量767 收藏
点赞数
分类专栏： c++ 文章标签： C++ 多态 VPTR VTABLE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Winge_Fish/article/details/47066895
版权

多态的概念：

多态性：是指具有不同功能的函数可以用同一函数名，即系统能够在运行时，

能够根据其类型确定调用哪个重载的成员函数。

面向对象中是这样表述多态性的：向不同的对象发送同一个消息，不同的对象在接收时产生不同的行为（即不同的实现）。

其实生活中，到处都是多态的例子。例如，学校校长向社会发布一个消息：9月1日新学年开学。不同的对象就会作出不同的响应：学生要准备好课本准时到校上课；家长要筹集学费；教师要备好课；后勤部门要准备好教室、宿舍和食堂....

多态性（polymorphism）提供了接口与具体实现之间的另一层隔离。

从系统实现的角度看:  多态性分为两类：静态多态性和动态多态性。

函数重载和运算符重载实现的多态性属于静态多态性。（静态联编，早捆绑）

动态多态性则是通过虚函数（Virtual Function）实现的。（动态联编，晚捆绑，是根据对象的类型）


虚函数允许一个类型表达自己与另一个相似类型之间的区别。

虚函数的作用：允许子类中重新定义与基类同名的函数，并且可以通过父类的指针或引用

访问父类和子类中的同名函数。


虚函数的使用方法是：


  1. 在父类中用  virtual 关键字声明成员函数为虚函数。这样就可以在子类中重新定义此函数，赋予新的功能。
  2. 在子类中重新定义此函数：要求函数名，函数返回值，函数的参数个数，类型全部与父类的虚函数相同。
  3. C++编译器规定，当一个成员函数被声明为虚函数后，其子类中的同名函数自动成为虚函数。（即当一个函数在父类
  4. 中被声明为virtual，那么在所有的子类中它都是virtual。）因此在子类重新声明该虚函数时，可加virtual，可不加但习惯上一般加上，使程序更清晰。
  5. 在子类中的重定义通常称为重写。



#include <iostream>
using namespace std;

class Parent
{
public:
	Parent(int a)
	{
		this->a = a;
		
	}
	virtual void print()//声明为虚函数
	{
		cout << "Parent 打印 a: " << a << endl;
	}
private:
	int a;
};


class Child : public Parent
{
public:
	Child(int b):Parent(10)
	{
		this->b = b;
		 
	}
    void print()
	{
		cout << "Child 打印 b: " << b << endl;
	}

private:
	int b;
};

int main()
{

	Parent	*base = NULL;
	Parent	p1(20);
	Child	c1(30);

	base = &p1;
	base->print();//执行父类的打印函数

	base = &c1;
	base->print();//执行子类的打印函数

	Parent &base2 = p1;//执行父类的打印函数
	base2.print();
	Parent &base3 = c1;//执行子类的打印函数
	base3.print();
	system("pause");
	return 0;
}


多态成立的三个条件

  1. 要有继承
  2. 要有虚函数重写
  3. 用父类指针（父类引用）指向子类对象

<span style="font-size:18px;">#include <iostream>
using namespace std;

class HeroFighter  //第一代飞机，父类
{
public:
	virtual int power()
	{
		return 10;
	}
};

class EnemyFighter //敌机
{
public:
	int attack()
	{
		return 15;
	}
};

class SecondFighter : public HeroFighter//第二代飞机
{
public:
	virtual int power()
	{
		return 20;
	}
};

void VsPlatform(HeroFighter *hf,EnemyFighter *ef )
{
		if(hf->power()>ef->attack())
		{
			cout << "主角胜利" << endl;
		}
		else
		{
			cout << "主角失败" << endl;
		}
};

int main()
{
	HeroFighter hf1;
	EnemyFighter ef1;
	SecondFighter sf1;
	VsPlatform(&hf1, &ef1);
	VsPlatform(&sf1, &ef1);
	
	system("pause");
	return 0;
}</span>

由以上的多态案例，可以看出多态的好处，在VsPlatform（）函数里面进行主角和敌机的战斗比较，只需要接受传过来的不同飞机的对象指针或者引用，即可，即使以后增加，第三代飞机，第四代飞机，....都不会影响VsPlatform（）函数的任何修改，只需要增加类，修改类而已。因此多态的作用：

  • 隐藏细节，使得代码能够模块化；扩展代码模块，实现代码重用。
  • 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一个属性时的正确调用。


虚析构函数

为什么需要在父类中定义虚析构函数？（虚析构函数作用）

因为当用new运算符建立临时对象，并且赋值给父类的指针变量，如果父类中的析构函数不是虚的

，delete运算符撤销对象时，会发生一个情况：系统只执行父类的析构函数，而不执行子类的析构函数。

析构函数可以是虚的，虚析构函数用于指引delete运算符正确析构动态对象。

（即通过父类的指针，释放所有子类的资源）

构造函数不能是虚函数。因为在执行构造函时，类对象还没完成建立对象过程，

建立一个派生类对象时，必须从类层次的根开始，沿着继承路径

逐个调用父类的构造函数。


#include <iostream>
using namespace std;

class Point
{
public:
	Point()
	{

	}
	virtual ~Point()//在父类中，声明为虚析构函数
	{
		cout << "我是父类的析构函数" << endl;
	}
};

class Circle : public Point
{
public:
	Circle()
	{

	}
	~Circle()
	{
		cout << "我是子类的析构函数" << endl;
	}
};
void deletobj()
{
	Point *p = new Circle; //父类指针指向 new运算符建立的临时对象
	delete p; //释放父类指针所指向的内存空间，会调用析构函数
}


int main()
{
	deletobj();
	 
	system("pause");
	return 0;
}


一个典型的多态案例深入剖析：


<span style="font-size:14px;">#include <iostream>
using namespace std;

enum note //定义个枚举
{
	middleC,Csharp,Cflat //中央C调，升C调，降C调
};

class Instrument //乐器类
{
public:
	virtual void play(note) const
	{
		cout << "乐器的播放" << endl;
	}
	virtual char* what()const
	{
		return "Instrument";
	}
	virtual void adjust(int ad) //函数体为空
	{

	}
};

class Wind : public Instrument  //Wind 是管乐器,继承于乐器类
{
public:
	virtual void play(note) const //play虚函数重写
	{
		cout << "Wind管乐器的播放" << endl;
	}
	virtual char* what()const //what虚函数重写
	{
		return "Wind";
	}
	virtual void adjust(int ad) 
	{

	}
};

class Percussion : public Instrument //Percussion是打击乐器
{
public:
	virtual void play(note) const //重写虚函数
	{
		cout << "Percussion打击乐器的播放" << endl;
	}
	virtual char* what()const //重写虚函数
	{
		return "Percussion";
	}
	virtual void adjust(int ad)
	{

	}
};

class Stringed : public Instrument //Stringed 是弦乐器
{
public:
	virtual void play(note) const
	{
		cout << "Stringed弦乐器的播放" << endl;
	}
	virtual char* what() const 
	{
		return "Stringed";
	}
	virtual void adjust(int ad)
	{

	}
};

class Brass : public Wind //Brass铜管乐器 继承于管乐器Wind
{
public:
	virtual void play(note) const
	{
		cout << "Brass铜管乐器的播放" << endl;
	}
	virtual char* what()const
	{
		return "Brass";
	}
};

class Woodwind : public Wind //Woodwind是木管乐器 继承于Wind
{
public:
	virtual void play(note) const
	{
		cout << "Woodwind木管乐器的播放" << endl;
	}
	virtual char* what() const 
	{
		return "Woodwind";
	}
};

void tune(Instrument &i) //tune是曲调， 用父类的引用做函数参数 来接收子类的对象
{
	i.play(middleC);
	//....
}

void f(Instrument &i)
{
	i.adjust(1);
}

Instrument* A[]= {  //定义一个乐器类指针数组
	new Wind,
	new Percussion,
	new Stringed,
	new Brass,
};

int main()
{
	Wind flute;			//长笛
	Percussion drum;	//鼓
	Stringed violin;	//小提琴
	Brass flugelhorn;   //粗管短号
	Woodwind recorder;  //竖笛
	tune(flute);
	tune(drum);
	tune(violin);
	tune(flugelhorn);
	tune(recorder);
	f(flugelhorn);
	system("pause");
	return 0;
}</span>


输出的结果是：



可以看出，这个例子在Wind下增加一层继承层，可是不管继承多少层，virtual机制仍会正确工作。

另外adjust函数没有实现具体重写，当出现这种情况时候，编译器自动调用继承层中“最近的”定义，

保证在调用次虚函数总是有某种定义。可以看到，在tune函数中，根据子类传过来的对象类型，

准确的输出，我们想要的结果。那是如何实现的呢？晚捆绑如何发生？

  其实所有的工作都是由C++编译器在幕后完成。也就是C++虚函数机制。

首先，在父类Instrument类中，关键字virtual告诉编译器它执行的是动态绑定，

晚捆绑，也就是常说的动态联编。为了达到这个目的，C++编译器对每个包含虚函数的类创建一个表（VTABLE（虚函数表）。在虚函数表中，编译器放置特定类的虚函数的地址。而在每个带有虚函数的类中，

编译器秘密地放置一个指针，称为(VPTR)（虚指针），指向这个对象的VTABLE（虚函数表）。当通过父类

指针或者引用做虚函数调用时，（多态调用时），编译器能取得这个VPTR并在虚函数表中查找函数地址的代码

这样就能调用正确的函数，并引起晚捆绑（动态联编）的发生。


可是我们没有看到VPTR指针，这是因为编译器帮我隐藏了。下面我们正面vptr指针的存在


<span style="font-size:14px;">#include <iostream>
using namespace std;

class NoVirtual
{
public:
	void x() const {}
	int getI()const { return 1;}
private:
	int a;
};

class OneVirtual 
{
public:
	virtual void x() const {}
	int getI()const { return 1;}
private:
	int a;
};

class TwoVirtual 
{
public:
	virtual void x() const {}
	virtual int getI()const { return 1;}
private:
	int a;
};


int main()
{
	cout << "int : " << sizeof(int) << endl;
	cout << "没有虚函数： " << sizeof(NoVirtual) << endl;
	cout << "void* : " << sizeof(void*) << endl;
	cout << "1个虚函数： " << sizeof(OneVirtual) << endl;
	cout << "2个虚函数： " << sizeof(TwoVirtual) << endl;
	system("pause");
	return 0;
}</span>

运行的结果是：




 可以看出，没有虚函数时候，就是int的长度，如果有了虚函数，不管多少个，对象的长度就是 int的长度+void指针的长度，也就是说，在这里（win32平台下） VPTR指针长度是4个字节。编译器的确在幕后，隐藏在含有虚函数的类中，加入了一个VPTR指针。

并且如果一个类中，没有任何的数据成员，C++编译器会强制对这个对象是非零长度，win32平台下是1个字节，

因为每个对象必须有一个互相区别的地址。

我们在回头看看刚才的例子，可以得出如下的图表：



在这个表中，编译器放置了在这个类中或在它的父类中的所有已经声明为virtual的函数的地址。

如果在子类中没有对在父类中声明为virtual函数的进行重定义，编译器就使用父类的这个虚函数地址。

如Brass类中adjust函数，因为没有进行虚函数（adjust）进行重定义，因为使用父类的adjust函数 ，

即（&Wind::adjust）

在这种简单继承中，对于每个对象只有一个VPTR。VPTR必须初始化为指向相应的虚函数表的起始地址。

而VPTR在初始化在构造函数中进行。


VPTR指针是分步初始化的。 看下面的案例

<span style="font-size:14px;">#include <iostream>
using namespace std;

//构造函数中调用虚函数，不能发生多态，被调用的只是这个函数的本地版本。

class Parent
{
public:
	Parent(int a=0)
	{
		this->a = a;
		print();//执行的是父类的print（）函数
	}

	virtual void print()  
	{
		cout<<"我是爹"<<endl;
	}

private:
	int a;
};

class Child : public Parent
{
public:
	Child(int a = 0, int b=0):Parent(a)
	{
		this->b = b;
		print();//执行的是子类的print（）函数
	}

	virtual void print()
	{
		cout<<"我是儿子"<<endl;
	}
private:
	int b;
};

void HowToPlay(Parent *base)
{
	base->print();  

}

void main()
{

	Child  c1; //定义一个子类对象 ,在这个过程中,在父类构造函数中调用虚函数print  
	//c1.print();

 
	system("pause");
	return ;
}</span>



要初始化c1.vptr指针，初始化是分步的。

当执行父类的构造函数的时候，c1.vptr指向的是父类的虚函数表，

当父类的构造函数运行完毕后，会把c1.vptr指针指向 子类的虚函数表。



结论：初始化子类C1.VPRT的指针是分步完成的。


通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址才能确定真正应用

调用的函数，而普通成员是在编译时就确定了调用的函数，在效率上，虚函数的效率要低。

出于效率考虑，没有必要将所有成员函数都声明为虚函数。


多态的重要意义：

设计模式的基础，是框架的基石。












Winge_Fish
关注
专栏目录
【C++核心篇】—— C++面向对象编程：继承、多态的相关语法和使用的详解，回顾学习看这一篇就足够了！！！
2401_82458959的博客
08-19 1223
在本篇文章中，主要是对C++的基础语法进行回顾学习，回顾学习C++的基本语法规则、数据类型、控制结构以及面向对象编程的基本思想。
面向对象三大特性之一——多态详解
weixin_59371851的博客
07-23 2116
哈喽，小伙伴们大家好。上一章我们一起学习了继承，今天我们继续来学习面向对象三大特性中的最后一个特性——多态。事不宜迟，快拿起小本本，跟我一起开始吧。一、多态的概念多态，顾名思义，也就是多种状态。通俗点说就是不同的对象去干同一件事情时会产生不同的状态。以买火车票为例，普通人买票就要付全款，学生买票就可以出半价，军人虽然不能优惠但是可以优先买票。放到我们程序中就是不同继承关系的类对象去调用同一个函数，会产生不同的状态。在了解多态的构成条件前，我们先来了解一个概念，虚函数。在同一个作用域。......
C++： 面向对象之多态
e.g.:
04-06 960
指向基类的指针 类继承的一个关键特性是，指向派生类的指针与指向基类的指针是类型兼容的。 多态是利用这个简单但功能强大且通用的特性的艺术。 // pointers to base class #include <iostream> using namespace std; class Polygon { protected: int width, height; public: void set_values (int a, int b) { width=a;
面向对象特性——C++多态性
Neil驱动的博客
08-25 308
1. 多态性是面向对象程序设计的关键技术之一。 2. 利用多态性技术，可以调用同一个函数名的函数，实现完全不同的功能。 3.C++中有两种多态性：编译时的多态性和运行时的多态性。 编译时的多态性：通过函数的重载的运算符的重载来实现 函数重载是根据函数调用时所给的实参类型和数量，在程序运行前就知道应该调用...
C++面向对象程序设计 - 多态性
最新发布
觉醒法师的专栏
05-08 1166
比如函数重载和运算符重载实现的多态性属于静态多态性，在程序编译时系统就能决定调用的是哪个函数，因此又称编译时的多态性；静态多态性是通过函数的重载实现的，运算符重载实质上也是函数重载。多态性是面向对象程序设计的一个重要特征，多态的意思是一个事物的多种形态。在C++程序设计中，多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数。面向对象方法中的多态性，比如说向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为（即方法）。
C++ 面向对象程序三大特性之 多态
WhiteShirtI的博客
05-02 1774
多态的概念 不同类的对象对同一消息作出不同的响应就叫做多态，通俗来讲，就是去完成某个行为，当不同的对象去完成时会产生出不同的结果 例如去网吧上机，如果你是vip，那么你上网的价格就会比普通用户上网的价格低；如果你不是vip，那么你上网的价格就是原价。这就是生活中的一种多态现象 多态的定义及使用 例如以下程序，就是一种多态的体现 class Vip { public: virtual void online() { cout << "7折优惠" << endl; } };
C++的多态性
Nemo
05-09 3595
概述 多态性是面向对象编程中的重要特征之一。其是用父类型别的指针（或引用）指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种由于调用子类的不同可以让父类的指针有“多种形态”，这是一种泛型技术。 多态实现方式： 函数重载 运算符重载 虚函数 多态实现 多态分类 1.编译时多态（静态联编） ： 通...
C++面向对象之多态的实现和应用详解
12-31
本文主要给大家介绍的是关于C++面向对象之多态的实现和应用的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧。 多态 大家应该都听过C++三大特性之一多态，那么什么多态呢？多态有什么用...
C++—面向对象三大特性以及多态重点详解
拥抱技术
06-30 1284
面向对象三大特性、C++多态详解
C面向接口编程和C++多态案例
吸喵高手的小窝
06-18 298
C/C++编程原则一条叫做，依赖倒置原则，即，依赖抽象而不依赖具体，当需要依赖一个类时，不应该直接依赖这个类的实例，而应该依赖这个类的父类接口。这里搜集了网上的资料，这个实例写的非常好。 https://www.cnblogs.com/yongqiang/p/5731243.html ...
C++多态性定义、实现以及示例详细介绍
Python966的博客
07-11 4245
C++多态性是面向对象程序设计中的重要概念，它允许子类对象具备父类对象的方法和属性。本文将详细介绍C++多态性的定义、实现以及示例，帮助初学者更好地理解和掌握多态性。
C++多态的实现及原理详细解析
weixin_30781775的博客
07-10 1623
C++的多态性用一句话概括就是： 在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。 如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数，此为多态的表现； 在看看以下几点： 1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2. 存在虚函数的类都有一个一维的虚函数表叫...
在 C++ 中多态是如何实现的
荣书的博客
09-21 3095
多态是面向对象程序设计（OOP）的核心思想，其字面意思是多种形态。 当我们使用基类的引用或者指针调用基类中定义的一个函数时，我们并不知道该函数真正作用的对象是什么类型，它可能是一个基类的对象也可能是一个派生类的对象。如果该函数是虚函数，则直到运行时才会决定到底执行哪个版本，判断的依据是引用或指针绑定的对象的真实类型。 另一方面，对非虚函数的调用和通过对象进行的函数（虚函数或非虚函数）调用在编译时进行绑定。 1. 虚函数 对于某些函数，基类希望它的派生类各自定义适合自身的版本，此时基类就将这些函数声明成虚函数
c++面试题
qq_36864672的博客
07-24 494
c++面试题 一 用简洁的语言描述 c++ 在 c 语言的基础上开发的一种面向对象编程的语言； 应用广泛； 支持多种编程范式，面向对象编程，泛型编程，和过程化编程；广泛应用于系统开发，引擎开发；支持类，封装，重载等特性。 二 c 和 c++ 的区别 C++ 在 c 的基础上添加类；C主要是面向过程，C + + 主要面向对象；C主要考虑通过一个过程将输入量经过各种运算后得
2019-11-25
u012248443的博客
11-25 152
#include<iostream> using namespace std; enum note {middleC,Csharp,Eflat}; class instrument{ int a; //int b; /*int c; int d; int e; int f;*/ public: virtual void p...
C++编程思想 第1卷 第15章 多态性和虚函数 虚函数 扩展性
eyetired的博客
08-02 166
通过将play()在基类中定义为virtual,不用改变tune()函数就可以在系统中 随意增加新函数 更多的虚函数和一些新类，它们都能与老的版本一起正确工作，而不用改变 tune()函数 //: C15:Instrument4.cpp // From Thinking in C++, 2nd Edition // Available at http://www.BruceEckel.com...
c++_4: 多态_1_虚函数的定义
LandscapeMi
12-09 383
多态的概念 虚函数增强了类型的概念，而不是只是在结构内部隐藏代码； 向上类型转换函数调用的bangding 函数体和函数调用相联系称为捆绑 早捆绑 晚捆绑：运行时发生的捆绑-动态捆绑 virtual函数 派生类的函数—–重写 //向上类型转换#include <iostream> using namespace std; enum note { middleC,Csharp,Eflat };
C++之面向对象程序设计的基本特点（抽象、封装、继承、多态）
海阔天空sky的博客
04-09 8700
编写程序的目的就是描述和解决现实世界中的问题。第一步就是将现实世界中的对象和类如实的反映在程序中。 面向对象程序设计的主要特点：抽象、封装、继承、多态。 1、抽象 定义：对具体问题（对象）进行概括，抽出一类对象的公共性质并加以描述的过程。 两个方面：数据抽象和行为抽象。 例1:加入我们要在计算机上实现一个简单的时钟程序，通过对时钟进行分析可以看出，需要3个整型数据来存储时间，分别表示时、
C++面向对象编程：多态与课程详解
面向对象编程多态是面向对象程序设计的核心概念之一，特别是在C++这种广泛应用的编程语言中。C++由比雅尼·斯特劳斯特鲁普博士创造，他于1979年开始开发，起初称为"C with Class"，最终发展成现在的C++，并成为1998...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值