简单工厂模式

目录

适用场景

使用

UML类图

代码实现

优点

缺点

适用场景

• 对同样的数据不确定有多少种不同的逻辑处理
• 可能会增加新的逻辑处理

使用

计算器

• 计算器不但有简单的加、减、乘、除运算，也有平方、立方、指数等较为复杂的运算。
• 因此可以抽象出一个运算类，提供统一接口
• 根据不同的操作创建不同的运算子类
• 通过将运算符提供给工厂类选择具体的实现类

UML类图

代码实现

运算类

class Ope
{
public:
	Ope();
	~Ope();

public:
	double GetNums1() { return m_nums1; }
	double GetNUms2() { return m_nums2; }
	void SetNums1(double num) { m_nums1 = num; };
	void SetNums2(double num) { m_nums2 = num; };
	virtual double GetRes() { double res = 0; return res; };

private:
	double m_nums1;
	double m_nums2;

};

运算子类

class Add :public Ope
{
public:
	double GetRes()
	{
		return GetNums1() + GetNUms2();
	};
};

class Sub :public Ope
{

public:
	double GetRes()
	{
		return GetNums1() - GetNUms2();
	}
};

class Mul :public Ope
{
public:
	double GetRes()
	{
		return GetNums1() * GetNUms2();
	}
};

class Div :public Ope
{
public:
	double GetRes()
	{
		if (!GetNUms2())
		{

			std::cout << "div is 0" << std::endl;
			return 0;
		}

		return GetNums1() / GetNUms2();
	}
};

工厂类

class OpeFactory
{
public:
	Ope * createOpe(Oper ope) 
	{
		Ope * oper = NULL;
		switch (ope)
		{
		case Oper_Add:
			oper = new Add();
			break;
		case Oper_Sub:
			oper = new Sub();
			break;
		case Oper_Mul:
			oper = new Mul();
			break;
		case Oper_Div:
			oper = new Div();
			break;
		default:
			break;
		}
		return oper;
	}

};

int main()
{
	OpeFactory * opeFct = new OpeFactory();
	Ope * oper;
	oper = opeFct->createOpe(Oper_Add);
	oper->SetNums1(1);
	oper->SetNums2(2);
	double rst = oper->GetRes();
	std::cout << rst << std::endl;
	return 0;
}

优点

• 低耦合，可扩展性强
• 类内部可以自由修改
• 具有清晰的对外接口

缺点

具有多个运算子类的时候，工厂类的逻辑分支较多，处理复杂