一、案例

最近直播很流行，那么就拿直播来举个例子。

比如熊猫直播，直播间里的观众一般分为3中：

1.普通观众（可以观看和发弹幕）

2.房管（权限比普通观众高，可以封禁普通观众）

3.超管（权限比房管高，可以封禁房管甚至直播）

通过用户昵称前面的标记区分到底是哪一类观众，普通观众不显示任何内容，房管前面有一个房管标记，超管前面有一个超管标记：

二、条件表达式

现在，我们编写代码来实现区分这3种观众：

#include <iostream>
using namespace std;

int main()
{
	int iUserType;//用户类型。0:普通；1:房管；2:超管
	cin >> iUserType;
	if (iUserType == 0)
	{
		cout << "您是普通观众" << endl;
		cout << "不显示任何标记" << endl;
	}
	else if (iUserType == 1)
	{
		cout << "您是房管" << endl;
		cout << "显示房管标记" << endl;
	}
	else if (iUserType == 2)
	{
		cout << "您是超管" << endl;
		cout << "显示超管标记" << endl;
	}

	system("pause");
	return 0;
}

为了便于理解，上面的程序中没有考虑对错误的处理。

也许你觉得这样做就完了，但是这段代码明显不是面向对象的，不利于代码复用，没有“将业务逻辑和界面逻辑分开”。

所以接下来便是对业务的封装——

三、封装

观众类的头文件：

class Audience
{
public:
	Audience(int iUserType);
	~Audience();

	void showUserType();

private:
	int m_iUserType;
};

观众类的实现：

#include "Audience.h"
#include <iostream>
using namespace std;

Audience::Audience(int iUserType)
{
	m_iUserType = iUserType;
}

Audience::~Audience()
{
}

void Audience::showUserType()
{
	if (m_iUserType == 0)
	{
		cout << "您是普通观众" << endl;
		cout << "不显示任何标记" << endl;
	}
	else if (m_iUserType == 1)
	{
		cout << "您是房管" << endl;
		cout << "显示房管标记" << endl;
	}
	else if (m_iUserType == 2)
	{
		cout << "您是超管" << endl;
		cout << "显示超管标记" << endl;
	}
}

main函数：

int main()
{
	int iUserType;//用户类型。0:普通；1:房管；2:超管
	cin >> iUserType;
	Audience audience(iUserType);
	audience.showUserType();

	system("pause");
	return 0;
}

至此，业务和界面逻辑得以分离，代码的复用性也提高了。

那么，这样的程序是否已经足够了？

我们想想，现在观众分为3种类型，如果今后要增加或修改观众类型呢？比如添加一个系统管理员类型，他拥有封禁任何其他观众的权限。那么我们就需要增加一个条件判断，看起来没什么，实际上当程序很庞大时，这种修改很容易对原来良好的程序带来错误。而且增加一个条件判断，就要将之前的代码都重新编译一遍。

所以现在的程序时“紧耦合”的，可维护性不好。

一个更好的做法是将不同类型的用户分离。

四、类的分离

使用3个类，每个类对应一个类型的观众，在类内部进行一些其它操作。

1.编写3个类，每个类都有各自的shouUserType方法。

class CommonAudience;	　　　　 //普通观众
class HouseManager;		//房管
class SuperManager;		//超管

2.普通观众类的实现，另外2各类写法类似

#include "CommonAudience.h"

CommonAudience::CommonAudience()
{
}

void CommonAudience::showUserType()
{
	cout << "您是普通观众" << endl;
	cout << "不显示任何标记" << endl;
}

OK。到了这一步已经完成用户对象的分离。

下一步便是使用继承和多态，来获得究竟是哪一类观众。

在C++中，多态的作用是根据对象的不同类型而采取不同的行为。

回顾一下多态的用法，声明基类的指针，利用该指针指向任意一个子类对象，调用相应的虚函数，根据指向的子类的不同而实现不同的方法。

五、多态

对代码进行重构：

1.创建一个用户基类

class User
{
	virtual void showUserType();
};

声明用于显示用户类型的虚函数，注意是虚函数，否则无法使用多态。

2.创建继承它的三个子类

class CommonAudience : User
{
	void showUserType(){...}
};

class HouseManager : User
{
	void showUserType(){...}
};

class SuperManager : User
{
	void showUserType(){...}
};

那么，如何知道是哪一类用户呢？这需要用到设计模式中的简单工厂模式：

#include "UserFactory.h"

UserFactory::UserFactory()
{
}

User * UserFactory::createUser(int iUserType)
{
	User *user = nullptr;
	switch (iUserType)
	{
	case 0:
		user = new CommonAudience();
		break;
	case 1:
		user = new HouseManager();
		break;
	case 2:
		user = new SuperManager();
		break;
	default:
		break;
	}
}

这样只要知道用户类型，工厂就实例化出合适的对象，通过多态返回父类的方式，实现相应的输出。

int main()
{
	int iUserType;//用户类型。0:普通；1:房管；2:超管
	cin >> iUserType;
	User *user = UserFactory::createUser(iUserType);
	user->showUserType();
	system("pause");
	return 0;
}

“以多态取代条件表达式”只需在工厂创建实例时需要一次条件判断，后面就不再需要判断了，提高了效率。而且代码的结构得以改善，如果需要增加其它用户类型，只需再写一个集成自User基类的子类，便于扩展和维护。

六、总结

我们的流程是：

面向过程 ——> 面向对象：提高代码的可复用性；

if语句　——＞　多态　：　提高代码的可维护和可扩展性（同时提高了程序的效率，因为工厂类创建对象后，调用该对象的方法就无需条件判断了）

源码已放在我的github上：点我