【学习篇】【C++】【类和对象】【多态】

最新推荐文章于 2024-07-25 17:57:45 发布

Shiloh.Tse is coding

最新推荐文章于 2024-07-25 17:57:45 发布

阅读量106

点赞数

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

本文链接：https://blog.csdn.net/weixin_44469133/article/details/112253361

版权

C++ 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

多态

一、基本概念
- 1.静态多态和动态多态
二、纯虚函数和抽象类
三、虚析构和纯虚析构
四、案例

一、基本概念

1.静态多态和动态多态

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

【区别】
静态多态的函数地址早绑定——编译阶段确定
动态多态的函数地址晚绑定——运行阶段确定

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();
}
void test01()
{
	Cat cat;
	doSpeak(cat);
	Dog dog;
	doSpeak(dog);
}

根据编译结果可以看出
在这里插入图片描述

动态多态的满足条件：

有继承关系
子类重写父类的虚函数。重写是指函数返回值类型函数名参数列表完全相同

动态多态使用：

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

二、纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容。

因此可以改为纯虚函数。语法：virtual 返回值类型函数名（参数列表） = 0;

当类中有了纯虚函数，这个类也称为抽象类。抽象类特点：

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

class Base
{
public:
	virtual void func() = 0;
};

class Son : public Base
{
public:
	void func()
	{
		cout << "Son func()的调用" << endl;
	}
};

void test01()
{
	//Base b; //抽象类无法实例化对象
	//new Base; //抽象类无法实例化对象
	Son s1; //子类必须重写父类中的纯虚函数，否则无法实例化对象。
	Base* base = new Son;
	base->func();
}

三、虚析构和纯虚析构

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

【解决办法】将父类中的析构函数改为虚析构或者纯虚析构

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

区别：
• 如果是纯虚析构，该类属于抽象类

虚析构语法：virtual ~类名(){}
纯虚析构语法：（类内声明）virtual ~类名() = 0; （类外定义）类名::~类名(){}

在例子中，如果基类的析构函数不是虚析构，

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

则结果会出现下面的情况，这就意味着由子类Cat开辟的由指针m_name指向的堆区数据没有被释放。
在这里插入图片描述

因此为了使父类指针释放子类对象，下面有两种方式，分别是虚析构和纯虚析构

虚析构（类内声明和定义）

class Animal
{
public:
	virtual void speak() = 0;
	Animal()
	{
		cout << "Animal的构造函数调用" << endl;
	}
	virtual ~Animal()
	{
		cout << "Animal的析构函数调用" << endl;
	}
};

纯虚析构（类内声明，类外定义）

class Animal
{
public:
	virtual void speak() = 0;
	Animal()
	{
		cout << "Animal的构造函数调用" << endl;
	} 
	virtual ~Animal() = 0;
};
Animal::~Animal()
{
	cout << "Animal纯虚析构函数调用" << endl;
}

通过这种方式，编译后的结果就变成了
在这里插入图片描述

总结：
1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2. 如果子类中没有堆区数据，析构函数可以不写成虚析构或纯虚析构
3. 拥有纯虚析构函数的类也属于抽象类

class Cat :public Animal
{
public:
	string* m_Name;
public:
	Cat(string name)
	{
		cout << "Cat的构造函数调用" << endl;
		m_Name = new string(name);
	}
	void speak()
	{
		cout << *m_Name << "喵喵" << endl;
	}
	~Cat()
	{
		cout << "Cat的析构函数调用" << endl;
		if (m_Name != NULL)
		{
			delete m_Name;
			m_Name = NULL;
		}
	}
};
void test()
{
	Animal* animal = new Cat("Tom");
	animal->speak();
	//父类指针在析构时候，不会调用子类中的析构函数，导致子类如果有堆区属性，出现内存泄漏 
	delete animal;
}

四、案例

1.计算器

先写一个普通的计算器

class Calculator
{
public:
	int m_num1;
	int m_num2;
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;
		}
	}
};

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:
	int m_num1;
	int m_num2;
public:
	virtual int getResult()
	{
		return 0;
	}
};

//加法计算器类
class AddCalculator : public AbstractCalculator
{
public:
	int getResult()
	{
		return m_num1 + m_num2;
	}
};
//减法计算器类
class SubtractCalculator : public AbstractCalculator
{
public:
	int getResult()
	{
		return m_num1 - m_num2;
	}
};
//乘法计算器类
class MultiplyCalculator : 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 SubtractCalculator;
	abc->m_num1 = 10;
	abc->m_num2 = 10;
	cout << abc->m_num1 << " - " << abc->m_num2 << " = " << abc->getResult() << endl;
	delete abc;//用完后销毁

	abc = new MultiplyCalculator;
	abc->m_num1 = 10;
	abc->m_num2 = 10;
	cout << abc->m_num1 << " * " << abc->m_num2 << " = " << abc->getResult() << endl;
	delete abc;//用完后销毁
}

在真实开发中提倡开闭原则，对扩展进行开放，对修改进行关闭。

2.制作饮品

#include <iostream>
#include<string>
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 << "煮水" << 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* abc)
{
	abc->MakeDrink();
	delete abc;//释放
}

void test01()
{
	//制作咖啡
	dowork(new coffee); //AbstractDrinking* abc = new coffee

	//制作茶
	dowork(new tea); //AbstractDrinking* abc = new tea
}

int main()
{
	test01();
	return 0;
}

3.电脑组装

#include<iostream>
#include<string>
using namespace std;


class CPU {
public:
	virtual void calculate() = 0;
};

class VideoCard {
public:
	virtual void display() = 0;
};

class Memory {
public:
	virtual void storage() = 0;
};

class Computer {
private:
	CPU* m_cpu;
	VideoCard* m_vc;
	Memory* m_mem;
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;
		}
	}
};

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;
	}
};

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;
	cout << "第二台电脑开始工作：" << endl;
	Computer* computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);;
	computer2->work();
	delete computer2;

	cout << "-----------------------" << endl;
	cout << "第三台电脑开始工作：" << endl;
	Computer* computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);;
	computer3->work();
	delete computer3;

}

int main(){
	test01();
	//system("cls"); //清屏
	return 0;
}