C++基础（18）——多态

最新推荐文章于 2023-03-26 08:29:10 发布

AI炮灰

最新推荐文章于 2023-03-26 08:29:10 发布

阅读量269

点赞数 2

分类专栏： C++基础学习与实战文章标签：多态 c++

本文链接：https://blog.csdn.net/bigData1994pb/article/details/119032062

版权

C++基础学习与实战专栏收录该内容

25 篇文章 8 订阅

订阅专栏

1.多态的基本概述

1.1概念

多态是C++面向对象三大特性之一，多态分为两类：

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

1.2区别

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

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

1.3案例分析

#include<iostream>
using namespace std;

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

class Cat :public Animal {
public:
	void speak() {
		cout << "小猫再说话" << endl;
	}
};

//执行说话的函数
//地址早绑定，再编译阶段就确定了函数地址
void dospeak(Animal& animal) {//Animal& animal=cat
	animal.speak();
}

void test01() {
	Cat cat;
	dospeak(cat);
}
void main() {
	test01();

}

我们想既然传入的是cat对象，肯定是想输出猫再说话，为什么输出动物在说话呢？是因为静态多态的函数地址早绑定，编译阶段确定函数地址。就因为void dospeak(Animal& animal) 传入的是一个Animal对象，引用也好调入一个对象也好，调用dospeak（）函数不管传入猫或者狗，都会走animal里面的dospeak（）。如果我们要想让猫说话，我们利用动态多态，也就是让地址晚绑定。

只需要在dospeak（）函数前面加一个virtual这个函数就称为虚函数，这就完成了地址晚绑定。如下：

2.动态多态满足的条件

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

注：

重写：函数返回值类型，函数名参数列表完全相同，重写不是覆盖，而是在子类中父类的函数会被隐蔽

重载：函数返回值类型，函数名相同，参数的顺序，数量等不同

3.多态的原理剖析

Animal内存结构图

Cat结构图：

当我注释了Cat的dospek函数重写的部分，Cat的所有部分都是继承的，Cat类中也有4个字节，他继承了Animal类中的vfptr，vfptr指向的是vftable，记录的是Animal的dospeak()的函数。如上图
当发生重写的时候，字节还是4 ，还是继承了父类的vfptr指向vftable,但是vfptr指向vftable的数据被覆盖了，换成了猫的dospeak()函数入口地址，所以在传入猫的dospeak()就指向的是猫在说话了。如下图

4.多态的案例1

4.1案例描述

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

4.2多态的优点

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

4.3实现

4.3.1普通写法

#include<iostream>
using namespace std;

//普通计算器写法
class Calculate 
{
public:
	int getResult(string oper) 
	{
		if (oper == "+") 
		{
			return mNum1 + mNum2;
		}
		else if (oper=="-")
		{
			return mNum1 - mNum2;
		}
		else if (oper == "*")
		{
			return mNum1 * mNum2;
		}
		//普通写法的不好之处是，如果我要继续写除法，要继续的修改源码，后面要开发乘方，开方等功能还要继续的修改源码
	}
	int mNum1;
	int mNum2;
};
void test01() {
	Calculate c;
	c.mNum1 = 10;
	c.mNum2 = 10;
	cout << c.mNum1 << "+" << c.mNum2 << "=" << c.getResult("+") << endl;
	cout << c.mNum1 << "-" << c.mNum2 << "=" << c.getResult("-") << endl;
	cout << c.mNum1 << "*" << c.mNum2 << "=" << c.getResult("*") << endl;
}

void main() 
{
	test01();
}

普通写法的不好之处是，如果我要继续写除法，要继续的修改源码，后面要开发乘方，开方等功能还要继续的修改源码.

因此在实际的开发过程中，提倡开闭原则：即为对扩展进行开发，对修改进行关闭。

#include<iostream>
using namespace std;

//利用多态实现计算器
//实现计算器的抽象类
class AbstractCalculator 
{//这个类什么都不写只写操作数
public:
	virtual int getResult()//我们要实现多态是父类中有一个虚函数，子类区重写它
	{

		return 0;
	}
	int mNum1;
	int mNum2;
};

//加法计算器的类
class AddCalculator:public AbstractCalculator
{
public:
	int getResult()
	{
		return mNum1 + mNum2;
	}
};

//减法计算器的类
class SubCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return mNum1 - mNum2;
	}
};

//乘法计算器的类
class MulCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return mNum1 * mNum2;
	}
};

void test02() {
	//多态的使用条件：
	//父类的指针或者引用指向子类的对象
	
	//加法运算
	AbstractCalculator* abc = new AddCalculator;//用父类的指针创建一个AddCalculator对象
	abc->mNum1 = 10;
	abc->mNum2 = 10;
	cout << abc->mNum1 << "+" << abc->mNum2 << "=" << abc->getResult() << endl;

	//加法用完记得销毁
	delete abc;

	//减法运算
	abc = new SubCalculator;
	abc->mNum1 = 10;
	abc->mNum2 = 10;
	cout << abc->mNum1 << "-" << abc->mNum2 << "=" << abc->getResult() << endl;

	//减法用完记得销毁
	delete abc;

	//乘法运算
	abc = new MulCalculator;
	abc->mNum1 = 10;
	abc->mNum2 = 10;
	cout << abc->mNum1 << "*" << abc->mNum2 << "=" << abc->getResult() << endl;

	//乘法用完记得销毁
	delete abc;
}

void main() 
{
	//test01();
	test02();
}

利用多态来写计算器的实现，虽然代码量上去了，但是所有的功能都是在一个模块，假设一个功能出错，只需要看哪一个小模块即可，可读性很强。

5.纯虚函数和抽象类

5.1概述

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类的重写内容，因此可以将虚函数改为纯虚函数。

5.2写法

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

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

5.3抽象类的特点

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

5.4多态案例2

5.4.1案例描述

制作饮品的大致流程：煮水-冲泡-倒入水杯-加入佐料

利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

假如煮咖啡步骤：煮水-冲泡咖啡-倒入水杯-加糖和牛奶

冲茶步骤：煮水-冲泡茶叶-倒入杯中-加柠檬

#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 << "煮农夫山泉" << 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) //形参AbstractDrinking *abs，传入实参可以传入一个new一个咖啡
{
	abs->makeDrink();
	delete abs;//释放，因此在test01中我们需要手动在堆区开辟一个空间，所以用完需要释放
}


void test01()
{
	//制作咖啡
	dowork(new Coffee);//形参AbstractDrinking *abs，传入实参可以传入一个new一个咖啡

	//制作茶叶
	cout << "——————————————————————————" << endl;
	dowork(new Tea);
}

void main() 
{
	test01();
}

6.虚析构和纯虚析构

6.1概述

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

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

6.2虚析构和纯虚析构

6.2.1虚析构和纯虚析构的共性

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

6.2.2虚析构和纯虚析构的区别

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

6.2.3语法

虚析构语法：virtual ~类名（）{}

纯虚析构语法：virtual ~类名（）=0；

#include<iostream>
using namespace std;

class Animal {
public:
	Animal() 
	{
		cout << "Animal的构造函数调用" << endl;
	}

	virtual ~Animal() //利用虚析构可以解决父类指针释放子类对象时不干净的问题
	{
		cout << "Animal的析构函数调用" << endl;
	}
	//纯虚函数
	virtual void speak() = 0;

};
class Cat :public Animal
{
public:
	Cat(string name)
	{
		mName = new string (name);//new一个string返回的是一个string的指针
	}
	virtual void speak()
	{
		cout << *mName << "小猫在说话" << endl;
	}
	~Cat()//释放mName
	{
		if (mName != NULL) {
			cout << "Cat的析构函数调用" << endl;
			delete mName;
			mName = NULL;
		}
	}
	string * mName;//小猫的名称不是简单的创建在栈上，而是给一个指针把名字创建在堆区上，有这个*mName指针去维护他
};

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

void main() 
{
	test01();
}

7.案例三

7.1案例描述

电脑主要组成部件为CPU（用于计算）、显卡（用于显示）、内存条（用于存储）将每个零件封装出抽象基类，并且提供给不同的厂商生产不同的零件，例如Inter厂商和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();
	}

	//提供析构函数释放3个电脑零件
	~Computer() {
		//释放CPU零件
		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;//CPU的零件指针
	VideoCard * m_vc;//显卡零件指针
	Memory* m_mem;//内存条零件指针
};

//具体的厂商

//Intel厂商
class IntelCPU :public CPU
{
public:
	virtual void calculate()
	{
		cout << "IntelCPU开始计算" << endl;
	}
};

class IntelVideoCard :public VideoCard
{
public:
	virtual void display()
	{
		cout << "Intel的显卡开始显示了" << endl;
	}
};

class IntelMemory :public Memory
{
public:
	virtual void stoage()
	{
		cout << "Intel的内存条开始存储了" << endl;
	}
};

//Lenovo厂商
class LenovoCPU :public CPU
{
public:
	virtual void calculate()
	{
		cout << "LenovoCPU开始计算" << endl;
	}
};

class LenovoVideoCard :public VideoCard
{
public:
	virtual void display()
	{
		cout << "Lenovo的显卡开始显示了" << endl;
	}
};

class LenovoMemory :public Memory
{
public:
	virtual void stoage()
	{
		cout << "Lenovo的内存条开始存储了" << endl;
	}
};


void test01()
{
	//开始组装不同的电脑
	//第一台电脑的零件，零件都是在堆区创建的，所以要进行释放
	CPU* intelCpu = new IntelCPU;
	VideoCard* intelCard = new IntelVideoCard;
	Memory* intelMem = new IntelMemory;
	创建一台电脑
	Computer* computer1 = new Computer(IntelCPU, intelCard, intelMem);
	computer1->work();
	delete computer1;
	//或者在电脑的类中提供一个析构函数释放电脑零件
	//delete intelCpu;
	//delete intelCard;
	//delete intelMem;

	//开始组装第二台电脑
	Computer* computer2 = new Computer(new LenovoCPU, new LenovoCard, new LenovoMem);
	computer1->work();
	delete computer1;
}
void main() 
{
	test01();
}