设计模式（C++实现）（三）——简单工厂模式

示例问题：

输入两个数和运算符号，得到结果？

分析：

在该问题，最开始运算符号，只有“+”，“-”，“*”，“/”，可是随着运算符的增加，该如何扩展程序？

解决方案：

Operation.h

在该文件中，实现运算的基类，并分别实现加、减、乘、除运算子类

#pragma once

//运算基类
class COperation
{
public:
	COperation()
	{
		m_iNumberA = -1;
		m_iNumberB = -1;
	}

	virtual ~COperation()
	{

	}

	void SetNumberA(int iNumber)
	{
		m_iNumberA = iNumber;
	}

	void SetNumberB(int iNumber)
	{
		m_iNumberB = iNumber;
	}

	int GetNumberA()
	{
		return m_iNumberA;
	}

	int GetNumberB()
	{
		return m_iNumberB;
	}

	virtual int GetResult() = 0;

private:
	int m_iNumberA;
	int m_iNumberB;
};

//加法运算
class COperationAdd : public COperation
{
public:
	COperationAdd()
	{
	}

	virtual ~COperationAdd()
	{
	}

	int GetResult()
	{
		int iNumberA = GetNumberA();
		int iNumberB = GetNumberB();
		int iResult = iNumberA + iNumberB;
		return iResult;
	}
};

//减法运算
class COperationSub : public COperation
{
public:
	COperationSub()
	{
	}

	virtual ~COperationSub()
	{
	}

	int GetResult()
	{
		int iNumberA = GetNumberA();
		int iNumberB = GetNumberB();
		int iResult = iNumberA - iNumberB;
		return iResult;
	}
};

//乘法运算
class COperationMul : public COperation
{
public:
	COperationMul()
	{
	}
	virtual ~COperationMul()
	{
	}

	int GetResult()
	{
		int iNumberA = GetNumberA();
		int iNumberB = GetNumberB();
		int iResult = iNumberA * iNumberB;
		return iResult;
	}
};

//除法运算
class COperationDiv : public COperation
{
public:
	COperationDiv()
	{
	}
	virtual ~COperationDiv()
	{
	}

	int GetResult()
	{
		int iNumberA = GetNumberA();
		int iNumberB = GetNumberB();
		int iResult = iNumberA / iNumberB;
		return iResult;
	}
};

OperationFactory.h

工厂类的实现，根据输入的运算符，决定输出的运算对象指针（决定工厂生产的原件）

#pragma once
#include "Operation.h"
#include <string>

class COperationFactory
{
public:
	COperationFactory()
	{
	}

	virtual ~COperationFactory()
	{
	}

	COperation* GetOperation(std::string strOperationName)
	{
		COperation* pOperation = nullptr;
		if ("+" == strOperationName)
		{
			pOperation = new(std::nothrow) COperationAdd();
		}
		else if ("-" == strOperationName)
		{
			pOperation = new(std::nothrow) COperationSub();
		}
		else if("*" == strOperationName)
		{
			pOperation = new(std::nothrow) COperationMul();
		}
		else if ("/" == strOperationName)
		{
			pOperation = new(std::nothrow) COperationDiv();
		}
		return pOperation;
	}
};

main.cpp

// main.cpp : 定义控制台应用程序的入口点。
//

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

int main()
{
	COperationFactory Factory;
	COperation* pOperation = nullptr;
	pOperation = Factory.GetOperation("+");
    if (nullptr != pOperation)
	{
	    pOperation->SetNumberA(20);
	    pOperation->SetNumberB(4);
	    int iResult = pOperation->GetResult();
	    std::cout << "结果：" << iResult << std::endl;
	    delete pOperation;
	    pOperation = nullptr;
	}
	system("pause");
    return 0;
}

简单工厂模式的使用：

简单工厂模式，又叫做静态工厂方法（Static Factory Method）模式，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

何时使用简单工厂模式：

工厂类负责创建的对象比较少（由于如果需要添加新的类，就需要改变工厂类）；

客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；

简单工厂模式的缺点：

由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。

该缺点在工厂方法模式中得到了一定的克服。

 

返回目录：设计模式（C++实现）（总）

上一篇：设计模式（C++实现）（二）——单例模式

下一篇：设计模式（C++实现）（四）——工厂方法模式