C++入门day12（多态）

最新推荐文章于 2024-08-09 10:25:03 发布

闲看庭花

最新推荐文章于 2024-08-09 10:25:03 发布

阅读量136

点赞数

分类专栏： C++入门文章标签： c++

本文链接：https://blog.csdn.net/weixin_45982321/article/details/114505404

版权

C++入门专栏收录该内容

23 篇文章 0 订阅

订阅专栏

文章目录

多态

多态

多态的基本概念

多态分为两类：

静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态

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

静态多态的函数地址早绑定 – 编译阶段确定函数地址
动态多态的函数地址晚绑定 – 运行阶段确定函数地址

加 virtual，晚绑定

重载：函数名相同，参数不同
重写：什么都同，继承的时候子类覆盖父类

动态多态的满足条件：

有继承关系
子类重写父类的虚函数

动态多态的使用：

父类的指针或者引用，执行子类对象

空类占 1 个字节，加 virtual 后，就是加了一个指针了，4 个字节

vfptr  -- 虚函数（表）指针
vftable -- 虚函数表

virtual
function
pointer
table

类和对象-多态-多态的原理剖析

#include <iostream>
using namespace std;
// 多态概念 
class Animal
{
	public:
		virtual 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)
{
	animal.speak();  // 地址早绑定 --> 动物在说话  --> 加 virtual 变晚绑定 
}
int main()
{
	Cat cat;
	doSpeak(cat);
	Dog dog;
	doSpeak(dog);
	
	system("pause");
	return 0;
}

运行结果：

小猫在说话
小狗在说话
请按任意键继续. . .

多态案例 – 计算器类

案例描述：
分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

多态的优点：

代码组织结构清晰
可读性强
利用前期和后期的扩展以及维护

开闭原则：对扩展开放，对修改关闭

#include <iostream>
#include <string>
using namespace std;
// 多态 -- 计算器类
// 普通写法
class Calculator
{
	public:
		int getResult(string oper)
		{
			if(oper=="+")
			{
				return m_Num1 + m_Num2;
			}
			else if(oper=="-")
			{
				return m_Num1 - m_Num2;
			}
		}
		int m_Num1;
		int m_Num2;
};
// 利用多态实现计算器
class AbstractCalculator
{
	public:
		virtual int getResult()
		{
			return 0;
		}
	int m_Num1;
	int m_Num2;
};
// 加法
class AddCalculator:public AbstractCalculator
{
	public:
		int getResult() 
		{
			return m_Num1 + m_Num2;
		}
};
// 乘法 
class MulCalculator:public AbstractCalculator
{
	public:
		int getResult()
		{
			return m_Num1 * m_Num2;
		}
};
// 普通 
void test()
{
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 10;
	cout<<c.getResult("+")<<endl;
	cout<<c.getResult("-")<<endl;
}
// 多态 
void test2()
{
	AbstractCalculator * abc = new AddCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 100;
	cout<<abc->getResult()<<endl;
	
	AbstractCalculator * cba = new MulCalculator;
	cba->m_Num1 = 100;
	cba->m_Num2 = 100;
	cout<<cba->getResult()<<endl;
}
int main()
{
	test();
	cout<<"----------"<<endl;
	test2();
	system("pause");
	return 0;
}

运行结果：

20
0
----------
200
10000
请按任意键继续. . .

纯虚函数和抽象类

在多态中，通常父类中的虚函数的实现是没有意义的，主要是用来调用子类重写的内容
这时可以写成“纯虚函数”

virtual 返回值类型 函数名 （参数列表） = 0；

当类中有了纯虚函数，这个类也叫“抽象类”

抽象类的特点：

无法实例化对象
子类必须重写抽象类中的纯虚函数，否则也属于抽象类

多态案例二 – 制作饮品

案例描述：
制作饮品的大致流程为：煮水 – 冲泡 – 倒入杯中 – 加入辅料
利用多态，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

#include <iostream>
using namespace std;
// 多态 -- 制作饮品
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<<"coffee--boil"<<endl;
		}
		virtual void Brew()
		{
			cout<<"coffee--brew"<<endl;
		}
		virtual void PourInCup()
		{
			cout<<"coffee--PourInCup"<<endl;
		}
		virtual void PutSomething()
		{
			cout<<"coffee--PutSomething"<<endl;
		}
};
class Tea:public AbstractDrinking
{
	public:
		virtual void Boil()
		{
			cout<<"Tea--boil"<<endl;
		}
		virtual void Brew()
		{
			cout<<"Tea--brew"<<endl;
		}
		virtual void PourInCup()
		{
			cout<<"Tea--PourInCup"<<endl;
		}
		virtual void PutSomething()
		{
			cout<<"Tea--PutSomething"<<endl;
		}
};
// 制作
void doWork(AbstractDrinking * abc)
{
	abc->makeDrink();
	delete abc;  // 手动开辟堆区，最好手动释放 
} 
void test()
{
	doWork(new Coffee);
	cout<<"-----------------"<<endl;
	doWork(new Tea);
}
int main()
{
	test();
	system("pause");
	return 0;
}

运行结果：

coffee--boil
coffee--brew
coffee--PourInCup
coffee--PutSomething
-----------------
Tea--boil
Tea--brew
Tea--PourInCup
Tea--PutSomething
请按任意键继续. . .

虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时，无法调用到子类的析构代码
解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

可以解决父类指针释放子类对象
都需要有具体的函数实现

虚析构和纯虚析构的区别：
如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：

virtual ~类名(){};

纯虚析构语法：

virtual ~类名() = 0;
类名::~类名(){}

纯虚析构，既要有声明，也要有实现，而且所在类还是抽象类

#include <iostream>
#include <string>
using namespace std;
// 虚析构和纯虚析构
class Animal
{
	public:
		Animal()
		{
			cout<<"Animal--构造函数"<<endl;
		}
		virtual ~Animal()
		{
			cout<<"Animal--虚析构函数"<<endl;
		}
		// virtual ~Animal() = 0;   // 纯虚析构 

		virtual void speak() = 0; 	// 纯虚函数
};
// 纯虚析构必须实现 
//Animal::~Animal()
//{
//	cout<<"Animal--纯虚析构函数"<<endl;
//} 
class Cat:public Animal
{
	public:
		Cat(string name)
		{
			cout<<"Cat--构造函数"<<endl;
			m_Name = new string(name);
		}
		virtual void speak()
		{
			cout<<*m_Name<<"小猫在说话"<<endl;
		}
		~Cat()
		{
			if(m_Name != NULL)
			{
				cout<<"Cat--析构函数"<<endl;
				delete m_Name;
				m_Name = NULL;
			}
		}
		string *m_Name;
};
void test()
{
	// 父类指针在析构的时候，不会调用子类的析构，因此会造成内存泄漏 
	// virtual ~Animal()  在父类析构那里使用虚析构
	// virtual ~Animal() = 0; 
	Animal * animal = new Cat("Tom");
	animal->speak();
	delete animal;
}
int main()
{
	test();
	system("pause");
	return 0;
}

运行结果：

Animal--构造函数
Cat--构造函数
Tom小猫在说话
Cat--析构函数
Animal--虚析构函数
请按任意键继续. . .

多态案例三 – 电脑组装

案例描述：

CPU（用于计算），显卡（用于显示），内存条（用于存储）
将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel和Lenovo
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试时组装三台不同的电脑进行工作

#include <iostream>
using namespace std;
// 多态 -- 电脑组装
// 零件 
// 抽象 CPU
class CPU
{
	public:
		virtual void calculate() = 0;
};
// 抽象 显卡
class VideoCard
{
	public:
		virtual void display() = 0;
};
// 抽象 内存条
class Memory
{
	public:
		virtual void storage() = 0;
};
// 电脑类
class Computer
{
	public:
		Computer(CPU * cpu, VideoCard * vc, Memory * mem)
		{
			m_cpu = cpu;
			m_vc = vc;
			m_mem = mem;
		}
		// 提供工作的函数
		void work()
		{
			m_cpu->calculate();
			m_vc->display();
			m_mem->storage();
		} 
		// 析构函数释放三个零件
		~Computer()
		{
			if(m_cpu != NULL)
			{
				delete m_cpu;
				m_cpu = NULL;
			}
			if(m_vc != NULL)
			{
				delete m_vc;
				m_vc = NULL;
			}
			if(m_mem != NULL)
			{
				delete m_mem;
				m_mem = NULL;
			}
		} 
	private:
		CPU * m_cpu;  // 零件指针 
		VideoCard * m_vc;
		Memory * m_mem;
};
// 具体厂商
// Intel
class IntelCPU:public CPU
{
	public:
		virtual void calculate()
		{
			cout<<"Intel的CPU开始计算了"<<endl;
		}
};
class IntelVideoCard:public VideoCard
{
	public:
		virtual void display()
		{
			cout<<"Intel的显卡开始显示了"<<endl;
		}
};
class IntelMemory:public Memory
{
	public:
		virtual void storage()
		{
			cout<<"Intel的内存条开始存储了"<<endl;
		}
};
// Lenovo
class LenovoCPU:public CPU
{
	public:
		virtual void calculate()
		{
			cout<<"Lenovo的CPU开始计算了"<<endl;
		}
};
class LenovoVideoCard:public VideoCard
{
	public:
		virtual void display()
		{
			cout<<"Lenovo的显卡开始显示了"<<endl;
		}
};
class LenovoMemory:public Memory
{
	public:
		virtual void storage()
		{
			cout<<"Lenovo的内存条开始存储了"<<endl;
		}
};
// 定制电脑
void test01()
{
	// 第一台电脑的零件 
	CPU * intelCpu = new IntelCPU;
	VideoCard * intelCard = new IntelVideoCard;
	Memory * intelMem = new IntelMemory;
	cout<<"---- 第一台电脑 ----"<<endl;
	// 创建第一台电脑
	Computer * computer1 = new Computer(intelCpu,intelCard,intelMem);
	computer1->work();
	delete computer1;
	cout<<"---- 第二台电脑 ----"<<endl;
	// 创建第二台电脑
	Computer * computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
	computer2->work();
	delete computer2;
	cout<<"---- 第三台电脑 ----"<<endl;
	// 创建第三台电脑
	Computer * computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);
	computer3->work();
	delete computer3;
} 
int main()
{
	test01();
	system("pause");
	return 0;
}

运行结果：

---- 第一台电脑 ----
Intel的CPU开始计算了
Intel的显卡开始显示了
Intel的内存条开始存储了
---- 第二台电脑 ----
Lenovo的CPU开始计算了
Lenovo的显卡开始显示了
Lenovo的内存条开始存储了
---- 第三台电脑 ----
Lenovo的CPU开始计算了
Intel的显卡开始显示了
Lenovo的内存条开始存储了
请按任意键继续. . .

闲看庭花

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++入门day12（多态）

文章目录多态多态的基本概念多态案例 -- 计算器类纯虚函数和抽象类多态案例二 -- 制作饮品虚析构和纯虚析构多态案例三 -- 电脑组装多态多态的基本概念多态分为两类：静态多态：函数重载和运算符重载属于静态多态，复用函数名动态多态：派生类和虚函数实现运行时多态静态多态和动态多态的区别：静态多态的函数地址早绑定 – 编译阶段确定函数地址动态多态的函数地址晚绑定 – 运行阶段确定函数地址加 virtual，晚绑定重载：函数名相同，参数不同重写：什么都同，继承的时候子类覆盖父类动
复制链接

扫一扫

专栏目录