动态多态的应用案例

计算机类

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

多态的优点：

代码组织结构清晰。

可读性强。

利于前期和后期的维护和拓展。

普通写法：

#include <iostream>
#include <Windows.h>
#include <string>

using namespace std;

class Calculator
{
public:
	int m_A;
	int m_B;
	int getResult(char oper)
	{
		switch (oper)
		{
			case '+':
				return m_A + m_B;
				break;
			case '-':
				return m_A - m_B;
				break;
			case '*':
				return m_A * m_B;
				break;
			default:
				break;
		}
	}
};

int main(void)
{
	// 创建计算器对象
	Calculator c;
	c.m_A = 10;
	c.m_B = 10;

	cout << c.m_A << " + " << c.m_B << " = " << c.getResult('+') << endl;
	cout << c.m_A << " - " << c.m_B << " = " << c.getResult('-') << endl;
	cout << c.m_A << " * " << c.m_B << " = " << c.getResult('*') << endl;

	system("pause");
	return 0;
}

运行截图：

        此时如果想要拓展除法功能，就必须要修改swith语句中的源码。但是，在开发中，提倡“开闭原则”。

        开闭原则：对拓展进行开放，对修改进行关闭。即：允许拓展源代码，但禁止修改源代码。

多态技术：

#include <iostream>
#include <Windows.h>
#include <string>

using namespace std;

// 实现计算器的抽象类
class AbstractCalculator
{
public:
	int m_A;
	int m_B;
	virtual int getResult()
	{
		return 0;
	}
};

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

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

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

int main(void)
{
	// 多态使用条件
	// 父类指针或引用接收子类对象
	
	// 加法运算
	AbstractCalculator* abc = new AddCalculator;
	abc->m_A = 10;
	abc->m_B = 5;

	cout << abc->m_A << " + " << abc->m_B << " = " << abc->getResult() << endl;

	// 释放堆区内存空间
	delete abc;

	// 减法运算
	abc = new SubCalculator;
	abc->m_A = 10;
	abc->m_B = 5;

	cout << abc->m_A << " - " << abc->m_B << " = " << abc->getResult() << endl;
	delete abc;

	// 乘法运算
	abc = new MulCalculator;
	abc->m_A = 10;
	abc->m_B = 5;

	cout << abc->m_A << " * " << abc->m_B << " = " << abc->getResult() << endl;
	delete abc;



	system("pause");
	return 0;
}

运行截图：

 多态的好处：

1、组织结构清晰：每个类的功能都不一样，不用把计算器的功能都杂糅到一个类中；如果减法功能出错了，可以迅速定位到源代码的位置，方便修改。

2、可读性强：子类重写父类的虚函数，加法类实现加法功能、减法类实现减法功能、乘法类实现乘法功能。

3、利于前期和后期的拓展以及维护性高：假如需要实现除法功能，就只需在源代码的基础上拓展一个除法类。而不是：修改源代码。

总结：C++开发提倡利用多态设计程序架构，因为多态的有点很多。

制作饮料

案例描述：制作饮料的大致流程：煮水、冲泡、倒入杯中。利用多态技术实现本案例，提供抽象类：制作饮料的基类（包含纯虚函数：煮水、冲泡、倒入杯中）。提供子类：制作咖啡和龙井。

#include <iostream>
#include <Windows.h>
#include <string>

using namespace std;

class Base
{
public:
	virtual void shaoshui() = 0; // 烧水
	virtual void chongpao() = 0; // 冲泡
	virtual void daoshui() = 0; // 倒入杯中
	void makeDrink() // 制作饮料
	{
		shaoshui();
		chongpao();
		daoshui();
	}
};

// 制作咖啡类
class Coffe : public Base
{
	void shaoshui()
	{
		cout << "烧矿泉水" << endl;
	}

	void chongpao()
	{
		cout << "冲泡咖啡" << endl;
	}

	void daoshui()
	{
		cout << "倒入马克杯" << endl;
	}

};

// 制作龙井类
class Tea : public Base
{
	void shaoshui()
	{
		cout << "烧山泉水" << endl;
	}

	void chongpao()
	{
		cout << "冲泡龙井" << endl;
	}

	void daoshui()
	{
		cout << "倒入茶杯" << endl;
	}

};


void doWork(Base* base)
{
	base->makeDrink();
	delete base;
}

int main(void)
{

	// 多态技术：根据实参类型，决定执行对应类的成员函数
	cout << "制作一杯咖啡：" << endl;
	doWork(new Coffe);	

	cout << endl;

	cout << "制作一杯龙井：" << endl;
	doWork(new Tea);
	

	system("pause");
	return 0;
}

运行截图：

电脑组成

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

#include <iostream>
#include <Windows.h>
#include <string>

using namespace std;

// 抽象不同零件类
// CPU类
class CPU
{
public:
	virtual void calculate() = 0;
};

// 内存条类
class Memory
{
public:
	virtual void storage() = 0;
};

// 电脑类
class Computer
{
private:
	CPU* m_cpu;
	Memory* m_memory;
public:
	Computer(CPU* cpu, Memory* memory)
	{
		m_cpu = cpu;
		m_memory = memory;
	}

	// 析构函数：释放类的堆区数据
	~Computer()
	{
		if (m_cpu != NULL)
		{
			delete m_cpu;
			m_cpu = NULL;
		}

		if (m_memory != NULL)
		{
			delete m_memory;
			m_memory = NULL;
		}
	}

	// 提供工作的函数
	void work()
	{
		// 让零件工作起来，调用接口
		m_cpu->calculate();
		m_memory->storage();
	}
};

// 具体厂商
class InterlCPU : public CPU
{
public:
	virtual void calculate()
	{
		cout << "Intel的CPU开始工作" << endl;
	}
};

class InterlMemory : public Memory
{
public:
	virtual void storage()
	{
		cout << "Intel的内存条开始工作" << endl;
	}

};



int main(void)
{
	// 电脑零件
	CPU* cpu = new InterlCPU;
	Memory* memory = new InterlMemory;

	// 创建一台电脑
	Computer* computer = new Computer(cpu, memory);
	computer->work();
	delete computer;
	

	system("pause");
	return 0;
}

运行截图：