多态（多接口）

在实际的开发中常常使用开闭原则：对扩展进行开发，对修改进行关闭。而多态可以很好的是实现这个原则。

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

class computer
{
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;
		}
		//如果想扩展新的功能，要求修改源码。 
		//在真的开发中体长开闭原则：对扩展进行开发，对修改进行关闭
	}

	int m_num1;
	int m_num2;
};

void test01()
{
	computer 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 abstractc
{
public:
	virtual int getresult()
	{
		return 0;
	}

	int m_num1;
	int m_num2;
};
//加法计算器的类
class addc :public abstractc
{
public:
	int getresult()
	{
		return m_num1 + m_num2;
	}
};
class subc :public abstractc
{
public:
	int getresult()
	{
		return m_num1 - m_num2;
	}
};
//乘法计算器类
class mulc :public abstractc
{
public:
	int getresult()
	{
		return m_num1 * m_num2;
	}
};

void test02()
{
	//多态使用条件  父类指针或者引用指向子类对象
	//加法
	abstractc* abc = new addc;
	abc->m_num1 = 100;
	abc->m_num2 = 100;
	cout << abc->m_num1 << "+" << abc->m_num2 << "=" << abc->getresult() << endl;
	delete abc;

	//减法运算
	abc = new subc;
	abc->m_num1 = 100;
	abc->m_num2 = 100;
	cout << abc->m_num1 << "-" << abc->m_num2 << "=" << abc->getresult() << endl;
	delete abc;

	//乘法
	abc = new mulc;
	abc->m_num1 = 100;
	abc->m_num2 = 100;
	cout << abc->m_num1 << "*" << abc->m_num2 << "=" << abc->getresult() << endl;
	delete abc;
}

上面这段代码，加减乘除可以放在同一个类下的成员函数中，但是如果是这样在日后如果要加一个开方平方之类的功能就需要重新改变源码，可以是不推荐的。可是如果在父类（虚基类）中只设置一个虚函数，然后再子类中对该虚函数具体化，分别实现加减乘除的功能，这样会带来很多的好处，例如可读性增强，然后如果要加要一个功能可以在创建一个子类来实例化增加该功能。

而父类中的一个虚函数可以在诸多的子类中分别实例化。然后在调用这个函数时候，如下面这段代码：

/*
多态案例2
我们制作饮品大概分为：煮水 冲泡 导入杯中 加入辅料
利用多态技术 提供抽象制作饮品类， 提供子类制作咖啡和茶叶


*/

class abstractd
{
public:
	virtual void boil() = 0;		//注水
	virtual void brew() = 0;		//冲泡
	virtual void pourin() = 0;		//倒入杯中
	virtual void putsth() = 0;		//加入辅料

	void makedrink()
	{
		boil();
		brew();
		pourin();
		putsth();
	}
};

//制作咖啡
class coffee :public abstractd
{
public:
	void boil()
	{
		cout << "煮农夫山泉" << endl;
	}
	void brew()
	{
		cout << "冲泡咖啡" << endl;
	}
	void pourin()
	{
		cout << "到入杯中" << endl;
	}
	void putsth()
	{
		cout << "牛奶" << endl;
	}
};
//制作茶叶
class tea :public abstractd
{
public:
	void boil()
	{
		cout << "矿泉水" << endl;
	}
	void brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	void pourin()
	{
		cout << "到入杯中" << endl;
	}
	void putsth()
	{
		cout << "枸杞" << endl;
	}
};
//void dowork(abstractd *abs)
//{
//	abs->makedrink();		//多态一个接口多个状态
//	delete abs;
//}
void dowo(abstractd& abst)
{
	abst.makedrink();
}
void test01()
{
	abstractd* abstract = new coffee;
	abstract->makedrink();
	
	//dowork(new coffee);
	cout << "------------" << endl;

	tea tea;
	abstractd& abst = tea;
	//dowo(tea);
	tea.makedrink();
	
	
}
int main()
{
	test01();
	//test02();
	return 0;
}

中间注释的那段代码被注释标注那行就是：多态一个接口多个状态。

通过传入new出的不同子类，以实参传给那段注释代码中的：abstractd *abs 下面的函数体中，传入的是哪个子类的类名就会调用哪个子类中的 makedrink函数。非常的方便。

在说一下多态的使用条件：父类指针或者引用指向子类对象，前提指向的是子类的对象，无论你是

coffee coffee这样还是 new coffee都是相当于创建了一个子类对象，在父类调用时候就可以分别通过：父类 &类名=子类类对象名字     和 父类 *类名=new 子类类名  这这两种方式分别通过父类引用和父类指针来运用多态