C++学习：多态

最新推荐文章于 2024-10-15 10:20:47 发布
最新推荐文章于 2024-10-15 10:20:47 发布
阅读量1k 收藏 19
点赞数 15
文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DesolateGIS/article/details/141938581
版权

目录

文章目录

一、多态的基本语法

二、多态的原理剖析

三、纯虚函数和抽象类

四、虚析构和纯虚析构

五、多态的案例

案例一:计算机类

案例二：制作饮品

总结

一、多态的基本语法

多态分为两类：

  • 静态多态: 函数重载和运算符重载属于静态多态，复用函数名

  • 动态多态: 派生类和虚函数实现运行时多态

静态多态和动态多态区别：

  • 静态多态的函数地址早绑定 - 编译阶段确定函数地址

  • 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

程序调用的结果是动物在说话，因为父类与子类的同名函数重载在c++中属于静态多态，函数的地址在编译阶段确定，所以只要是Animal类，都会调用Animal类的speak函数

但传入的是子类对象，要调用子类speak函数，所以不能在编译时确定Animal类的Speak函数地址，而要让子类对象传入是在确定函数地址，在Animal类的Speak成员前加上 virtual 关键字，使其成为虚函数，在程序运行时确定函数地址。

//动物类
class Animal
{
public:
	void Speak()
	{
		cout << "动物在说话" << endl;
	}
};

//猫类
class Cat : public Animal
{
public:
	void Speak()
	{
		cout << "小猫在说话" << endl;
	}
};

//狗类
class Dog : public Animal
{
public:
	void Speak()
	{
		cout << "小狗在说话" << endl;
	}
};

//执行说话的函数
void doSpeak(Animal& animal)	//在c++中，子类可以直接赋值给父类的引用 
{
	animal.Speak();
	//父类的函数与子类的同名函数重载，属于静态多态，在编译阶段确定地址
	//所以这里只要是Animal类都会调用Animal类的speak函数
}


//动物类
class Animal
{
public:
	virtual void Speak() //加上virtual关键字，使用动态多态，使函数地址在程序运行时确定
	{
		cout << "动物在说话" << endl;
	}
};

//猫类
class Cat : public Animal
{
public:
	void Speak()
	{
		cout << "小猫在说话" << endl;
	}
};

//狗类
class Dog : public Animal
{
public:
	void Speak()
	{
		cout << "小狗在说话" << endl;
	}
};

//执行说话的函数
void doSpeak(Animal& animal)
{
	animal.Speak();
}

多态满足条件：

  • 有继承关系

  • 子类重写父类中的虚函数

多态使用条件：

  • 父类指针或引用指向子类对象

重写：函数返回值类型 函数名 参数列表 完全一致称为重写

二、多态的原理剖析

将父类函数前的 virtual 关键字去掉，父类的函数变成了一个普通的成员函数，不属于类的对象上，类的大小为 1。

class Animal
{
public:
	void Speak()
	{
		cout << "动物在说话" << endl;
	}
};

void test01()
{
	cout << sizeof(Animal) << endl;
}

加上virtual关键词

运行程序得到输出结果为 4.因为原本的成员函数变成了一个vfpty指针(虚函数指针)，指针的大小为4，指向一个虚函数表（vftable）在表的内部会记录虚函数的地址，也就是Animal类中Speak()函数的地址。

 子类继承了父类，子类也会有一个虚函数指针指向一个虚函数表，但这个虚函数表中依然记录着父类Animal::Speak()的地址。

但在子类中重写Speak()函数时，虚函数表中的父类的函数地址就会被子类所替换，但父类记录的函数地址没有被替换。

这时候用父类的指针或者引用子类的对象时，就会发生多态，调用通过父类对象就可以通过虚函数表中的函数地址调用子类函数。

class Animal
{
public:
	virtual void Speak()
	{
		cout << "动物在说话" << endl;
	}
};


void test()
{
	cout << sizeof(Animal) << endl;
}

三、纯虚函数和抽象类

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;

抽象类特点：

  • 无法实例化对象

  • 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

class Base
{
public:

	//纯虚函数声明 

	virtual int func() = 0;	
};

class Son : public Base
{
public:

	int func()	//继承抽象类的子类必须重写纯虚函数，否则也为抽象类，不能实例化对象 
	{
		cout << "子类函数调用" << endl;
	}
};

void test01()
{
	//	Base b 抽象类不能实例化对象
	Base* base = new Son;
	base->func();
}

四、虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

  • 可以解决父类指针释放子类对象

  • 都需要有具体的函数实现

虚析构和纯虚析构区别：

  • 如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名() = 0;

类名::~类名(){}

Cat类在执行函数时会在堆区开辟空间。

将Cat对象创建在堆区，由于Animal是Cat的父类，会先调用Animal的构造函数，再调用Cat的构造函数，最后释放堆区空间，但是，由于用Animal指针释放堆区空间，所以这里不会执行Cat的析构函数，只会执行Animal的析构函数，没有释放堆区空间。

class Animal
{
public:
	
	Animal()
	{
		cout << "父类构造函数调用" << endl; 
	}
	virtual void Speak() = 0;
	
	~Animal()
	{
		cout << "父类析构函数调用" << endl;
	}
};
 
class Cat : public Animal
{
public:
	
	Cat(string name)
	{
		cout << "子类构造函数调用" << endl;
		m_Name = new string(name);
	}
	
	void Speak()
	{
		cout << *m_Name << "小猫在说话" << endl;
	}
	
	~Cat()
	{
		cout << "子类析构函数调用" << endl;
		if(m_Name != NULL)
		{
			delete m_Name;
			m_Name = NULL;
		}
	}
	
	string *m_Name = NULL;
};
 
void test()
{
	Animal *animal = new Cat("Tom"); //可以在new的同时给对象初始化
	animal -> Speak();
	delete animal;
}
 
int main()
{
	test();
	
	return 0;
}

将父类的析构函数变为虚函数，通过父类指针指向子类函数

class Animal
{
public:

	Animal()
	{
		cout << "父类构造函数调用" << endl;
	}
	virtual void Speak() = 0;

	virtual ~Animal()
	{
		cout << "父类析构函数调用" << endl;
	}
};

class Cat : public Animal
{
public:

	Cat(string name)
	{
		cout << "子类构造函数调用" << endl;
		m_Name = new string(name);
	}

	void Speak()
	{
		cout << *m_Name << "小猫在说话" << endl;
	}

	~Cat()
	{
		cout << "子类析构函数调用" << endl;
		if (m_Name != NULL)
		{
			delete m_Name;
			m_Name = NULL;
		}
	}

	string* m_Name = NULL;
};

void test01()
{
	Animal* animal = new Cat("Tom");
	animal->Speak();
	delete animal;
}

五、多态的案例

案例一:计算机类

普通实现

class Calculator 
{
public:
	int getResult(string oper)
	{
		if (oper == "+") 
        {
			return m_Num1 + m_Num2;
		}
		else if (oper == "-") 
        {
			return m_Num1 - m_Num2;
		}
		else if (oper == "*") 
        {
			return m_Num1 * m_Num2;
		}
		//如果想扩展新的功能，需求修改源码
		//在真实开发中 提倡开闭原则
		//开闭原则：对扩展进行开发，对修改进行关闭
	}
public:
	int m_Num1; //操作数1
	int m_Num2; //操作数2
};

void test01()
{
	//创建计算器对象
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 10;
	cout << c.m_Num1 << " + " << c.m_Num2 << " = " << c.getResult("+") << endl;

	cout << c.m_Num1 << " - " << c.m_Num2 << " = " << c.getResult("-") << endl;

	cout << c.m_Num1 << " * " << c.m_Num2 << " = " << c.getResult("*") << endl;
}

如果想扩展新的功能，需求修改源码

在真实开发中 提倡开闭原则

开闭原则：对扩展进行开发，对修改进行关闭

多态实现

//利用多态实现计算器
//多态优点：代码组织结构清晰，可读性强，利于前期和后期的扩展以及维护
class AbstractCalculator
{
public:

	virtual int getResult()
	{
		return 0;
	}

	int m_Num1;
	int m_Num2;
};

//加法计算器
class AddCalculator :public AbstractCalculator
{
public:
	virtual int getResult()
	{
		return m_Num1 + m_Num2;
	}
};

//减法计算器
class SubCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 - m_Num2;
	}
};

//乘法计算器
class MulCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 * m_Num2;
	}
};


void test02()
{
	//多态使用条件
	// 父类指针或者引用指向子类对象
	//创建加法计算器
	AbstractCalculator* abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;  

	//创建减法计算器
	abc = new SubCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;

	//创建乘法计算器
	abc = new MulCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;
}

案例二：制作饮品

利用多态实现制作咖啡和茶水
Coffee和Tea继承了抽象类AbstractDrinking，并重写了AbstractDrinking的抽象函数

class AbstractDrinking 
{
public:
	//煮水
	virtual void Boil() = 0;

	//冲泡
	virtual void Brew() = 0;

	//倒入杯中
	virtual void PourInCup() = 0;

	//加入辅料
	virtual void PutSomething() = 0;

	//规定流程
	void MakeDrink() {
		Boil();
		Brew();
		PourInCup();
		PutSomething();
	}
};

//制作咖啡
class Coffee : public AbstractDrinking 
{
public:
	//烧水
	virtual void Boil() 
	{
		cout << "煮农夫山泉!" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "冲泡咖啡!" << endl;
	}
	//倒入杯中
	virtual void PourInCup() 
	{
		cout << "将咖啡倒入杯中!" << endl;
	}
	//加入辅料
	virtual void PutSomething() 
	{
		cout << "加入糖和牛奶!" << endl;
	}
};

//制作茶叶
class Tea : public AbstractDrinking
{
public:
	//煮水
	virtual void Boil() 
	{
		cout << "煮矿泉水!" << endl;
	}
	//冲泡
	virtual void Brew() 
	{
		cout << "冲泡茶叶!" << endl;
	}
	//倒入杯中
	virtual void PourInCup() 
	{
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void PutSomething() 
	{
		cout << "加入枸杞" << endl;
	}
};

void doWork(AbstractDrinking* abs)
{
	abs->MakeDrink();
	delete abs;
}

void test01() 
{
	doWork(new Coffee);
	doWork(new Tea);
}

总结

以上是C++多态的内容。

DesolateGIS
关注
c++学习：多态案例之计算图形面积
weixin_42503072的博客
03-04 3120
虚函数 在类的定义中，前面有 virtual 关键字的成员函数就是虚函数。 例如： class base { virtual int get() ; }; int base::get() { } virtual 关键字只用在类定义里的函数声明中， 写函数体时不用。 多态的表现形式一 派生类的指针可以赋给基类指针。 通过基类指针调用基类和派生类中的同名虚函数时: （1）若该指针指向一个基类...
c++学习：多态案例之魔法门英雄无敌
weixin_42503072的博客
03-04 921
题目 游戏：魔法门之英雄无敌 游戏中有很多种怪物，每种怪物都有一个类与之对应，每个怪物就是一个对象 类： CSoldier CDragon CPhonex CAngel 怪物能够互相攻击，攻击敌人和被攻击时都有相应的动作，动作是通过对象的成员函数实现。 问题：游戏升级时，需要添加新的怪物–雷鸟，如何编程才能使得升级的时候代码改动和增加量较小 新增类：CThunderBird 1 为每个怪物...
c++学习：多态
weixin_59669309的博客
11-23 397
因为基类的getResult函数用virtual来修饰，表示虚函数，当继承了基类的派生类创建对象时，就会生成一个虚函数表，函数的地址就会存放在虚函数表里，当我们在派生类重写基类的getResult函数时，c++就会把重写后的函数地址替换掉虚函数表里的基类getResult函数地址，当我们调用的时候就会查到虚函数表的地址，进行调用所对应地址的函数。调用成员函数时，会根据调用函数的对象的类型来执行不同的函数，同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。属于静态多态，编译时多态。
C++学习八:多态
hhh8866223的博客
09-19 182
用父类的指针指向子类的实例，然后通过父类的指针调用子类的成员函数，一般有重写、重载重写是动态多态，重载是静态多态（编译器在编译期完成）多态的使用有三个前提条件：公有继承函数覆盖基类的引用/指针指向派生类对象。
C++12:多态
m0_53607711的博客
03-07 264
不同的对象执行相同的动作的时候产生不一样的效果，这一点有一点像函数重载，但是不一样的是我们控制的是传入的参数，而不是不同的对象。我们其实可以将这个行为形象的理解为"双标"。以“买东西”为例，不同的人购买商品的时候可能会因为身份的不同导致付出的金钱也不相同。那么如何实现多态呢？子类实现多态时，其实现多态的函数，但是这是一种不太好的行为，我们能加上就加上。
C++：多态（继承）
2301_80153885的博客
07-09 1223
在 C++ 中，多态性（Polymorphism）是面向对象编程中一个重要的概念，它允许使用统一的接口来操作不同的对象，从而提高代码的灵活性、可维护性和可扩展性。好啦，本章对于《C++：多态（继承）》的学习就先到这里，如果有什么问题，还请指教指教，希望本篇文章能够对你有所帮助，我们下一篇见！进行重写，重写后的虚函数会产生新的地址，放入虚表中。
C++学习进阶：多态
weixin_73234157的博客
11-03 96
在类与对象中重载一般出现在同一个类中的同名函数，参数不同 ，比如若干个构造函数重写一般出现在基类和派生类中的同名函数，且为虚函数，函数名/参数/返回值都需要一致，协变即为返回值分别为基类对象和子类对象重定义就是在基类和派生类的同名函数，但是不为虚函数，并且函数参数和返回值不做要求下面是3个例子初步稍微修改一下传入参数！
c++学习笔记：多态
qq_60143666的博客
04-09 1187
c++面向对象三大特征之一的多态的基本语法！
C++进阶：多态
yourfriendyo的博客
05-30 541
文章目录多态1. 多态的概念1.1 虚函数虚函数的定义重写的构成条件重写条件的例外1.2 多态的构成条件多态的效果1.3 重载重写隐藏对比重载重写隐藏1.4 final & overridefinal 修饰类final 修饰虚函数override2. 抽象类2.1 纯虚函数和抽象类2.2 接口继承和实现继承实现继承接口继承3. 多态的原理3.1 虚函数表虚表指针虚表的底层原理3.2 多态的实现原理3.3 动态绑定与静态绑定4. 不同继承关系的虚函数表4.1 单继承的虚函数表4.2 多继承的虚函数表4
C++学习笔记：多态
qq_42309130的博客
03-14 294
C++学习笔记:多态1.多态基本概念1.静态多态2.动态多态总结 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数，多态分为静态多态与动态多态。 多态使用条件:父类指针或引用指向子类对象 1.多态基本概念 1.静态多态 静态多态:函数重载和运算符重载等复用函数名为静态多态 2.动态多态 动态多态:派生类和虚函数实现运行时多态，需要在子类中对父类的虚函数进行重写 虚函数: virtual +函数 多态使用条件:父类指针或引用指向子类对象 #include <iostream
C++课程重点：多态与运算符重载
"本资源是何洁月教授在东南大学开设的C++课程的课件总结，主要内容...通过学习这个课程，学生不仅可以掌握C++语言的基础，还能理解面向对象编程的精髓，提升编程和调试能力，为后续的计算机科学学习打下坚实的基础。
C++面向对象：多态实战案例入门
在本章中，我们将深入探讨面向对象程序设计（Object-Oriented Programming，OOP...学习多态并应用于C++编程是面向对象程序设计旅程的重要一步，只有通过不断实践和掌握，才能真正发挥多态的优势，推动软件开发的进步。
C++面向对象编程：多态入门与C++历史详解
面向对象编程多态是C++学习中的重要概念，它在软件开发中扮演着核心角色。C++，由Bjarne Stroustrup博士创造，他是一位计算机科学家，曾在AT&T大规模程序设计研究部门工作，并且是C++之父。C++的设计初衷是对C语言...
MySQL数据库的详细学习步骤
2401_87352036的博客
10-11 1261
MySQL数据库的详细学习步骤可以归纳为以下几个阶段，每个阶段都包含了特定的学习内容和目标。
【人工智能学习之PaddleOCR快速上手】
Jiagym的博客
10-12 1327
在配置文件中，可以设置组建模型、优化器、损失函数、模型前后处理的参数，PaddleOCR从配置文件中读取到这些参数，进而组建出完整的训练流程，完成模型训练，在需要对模型进行优化的时，可以通过修改配置文件中的参数完成配置，使用简单且方便修改。而 L2 正则化中，添加正则化项的目的在于减少参数平方的总和。准确检测的标准是检测框与标注框的IOU大于某个阈值，正确识别的检测框中的文本与标注的文本相同。如果缺少带标注的数据，或者不想投入研发成本，建议直接调用开放的API，开放的API覆盖了目前比较常见的一些垂类。
如何用3个月零基础入门网络安全？_网络安全零基础怎么学习
最新发布
2401_84466224的博客
10-15 1119
我们知道计算机最早是在西方发明出来的，很多名词或者代码都是英文的，甚至现有的一些教程最初也是英文原版翻译过来的，而且一个漏洞被发现到翻译成中文一般需要一个星期的时间，在这个时间差上漏洞可能都修补了。”答案是否定的，黑客用的电脑,不需要什么高的配置,只要稳定就行.因为黑客所使用的一些程序,低端CPU也可以很好的运行,而且不占什么内存.还有一个,黑客是在DOS命令下对进行的,所以电脑能使用到最佳状态!观看学习近十年所有0day挖掘的帖，然后搭建环境，去复现漏洞，去思考学习笔者的挖洞思维，培养自己的渗透思维。
论文及其创新点学习cvpr2022 On the Integration of Self-Attention and Convolution
qq_53536373的博客
10-13 479
论文创新点，将注意力机制 和卷积 相结合。
stm32单片机个人学习笔记9（TIM输入捕获）
2302_80867398的博客
10-13 247
从模式选择Reset模式可以实现自动清零计数器CNT。
苍穹外卖学习笔记(二十一)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
10-13 348
取消订单与再来一单
C++学习：多态的核心——虚函数解析
"这篇文档是关于C++学习的笔记，主要关注多态性和虚函数的使用。文中通过实例介绍了如何声明和实现虚函数，并提到了C++的学习资源和历史背景，包括C++之父Bjarne Stroustrup的工作以及C++在不同阶段的发展。此外，还...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值