目录

一、基本概念

（1）分类

（2） 注意事项

（3）示例代码

 二、利用多态实现一个计算机类

首先用普通的写法实现

然后是多态的写法

三、利用多态实现饮品类

一、基本概念

（1）分类

多态分类两类：

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

两者之家的区别在于：

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

（2） 注意事项

①动态多态的满足条件：

• 得有继承关系
• 子类要重写父类的虚函数（与重载有区别，函数返回值类型、函数名、参数列表要完全相同）

②动态多态的使用：

• 父类的指针或者引用指向在子类对象

（3）示例代码

#include
using namespace std;

//多态
//动物类
class Animal
{
public:
	//virtual虚函数的关键字，加上后实现地址的晚绑定
	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 & animal = cat;
{
	animal.speak();
}

void test01()
{
	Cat cat;
	doSpeak(cat);

	Dog dog;
	doSpeak(dog);
}

int main()
{
	test01();
}

加上virtual之前，即早绑定的话：

加上virtual之后，即晚绑定的话：

 二、利用多态实现一个计算机类

首先用普通的写法实现

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

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

int main()
{
	test01();
}

然后是多态的写法

//利用多态实现计算机类
//实现计算机抽象类
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 SubCalculator:public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 - m_Num2;
	}
};

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

void test02()
{
	//多态使用条件
	//①父类指针或者引用指向子类对象

	//多态的好处
	//①代码组织结构清晰
	//②代码可读性强
	//③便于后期扩展和维护

	//加法运算
	AbstractCalculator* a = new AddCalculator;
	a->m_Num1 = 100;
	a->m_Num2 = 100;
	cout << a->m_Num1 << "+" << a->m_Num2 << "=" << a->getResult() << endl;
	delete a;

	//减法运算
	AbstractCalculator* b = new SubCalculator;
	b->m_Num1 = 100;
	b->m_Num2 = 100;
	cout << b->m_Num1 << "-" << b->m_Num2 << "=" << b->getResult() << endl;
	delete b;

	//乘法运算
	AbstractCalculator* c = new MulCalculator;
	c->m_Num1 = 100;
	c->m_Num2 = 100;
	cout << c->m_Num1 << "*" << c->m_Num2 << "=" << c->getResult() << endl;
	delete c;
}
int main()
{
	test02();
}

三、利用多态实现饮品类

 多态就是相同的接口，根据传入参数的不同实现不同的功能。

#include
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
{
	//煮水
	virtual void Boil()
	{
		cout << "煮水" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "冲泡咖啡" << endl;
	}
	//倒入杯中
	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void PutSomething()
	{
		cout << "加入牛奶和糖" << endl;
	}
};

//制作茶
class Tea :public AbstractDrinking
{
	//煮水
	virtual void Boil()
	{
		cout << "煮水" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	//倒入杯中
	virtual void PourInCup()
	{
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void PutSomething()
	{
		cout << "加入枸杞" << endl;
	}
};

void doWork(AbstractDrinking *a)
{
	a->makeDrink();
	delete a;
}

void test01()
{
	//制作咖啡
	doWork(new Coffee);
	cout << "-----------------------" << endl;
	//制作茶
	doWork(new Tea);
}

int main()
{
	test01();

	system("pause");
	return 0;
}