设计模式（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;
	}
};

FactoryMethod.h

在该文件中实现了工厂基类IFactory（生产运算操作），加法工厂类CFactoryAdd（生产加法运算），减法工厂类CFactorySub（生产减法运算），乘法工厂类CFactoryMul（生产乘法运算），除法工厂类CFactoryDiv（生产除法运算）

#pragma once

#include "Operation.h"
#include <new>

//工厂基类，能够生产运算操作
class IFactory
{
public:
	IFactory()
	{

	}

	virtual ~IFactory()
	{

	}

	virtual COperation* CreateOperation() = 0;
};

//加法工厂
class CFactoryAdd : public IFactory
{
public:
	CFactoryAdd()
	{

	}

	virtual ~CFactoryAdd()
	{

	}

	COperation* CreateOperation()
	{
		return new(std::nothrow) COperationAdd();
	}
};

//减法工厂
class CFactorySub : public COperation
{
public:
	CFactorySub()
	{

	}

	virtual ~CFactorySub()
	{

	}

	COperation* CreateOperation()
	{
		return new(std::nothrow) COperationSub();
	}
};

//乘法工厂
class CFactoryMul : public IFactory
{
public:
	CFactoryMul()
	{

	}

	virtual ~CFactoryMul()
	{

	}

	COperation* CreateOperation()
	{
		return new(std::nothrow) COperationMul();
	}
};

//除法工厂
class CFactoryDiv : public IFactory
{
public:
	CFactoryDiv()
	{

	}

	virtual ~CFactoryDiv()
	{

	}

	COperation* CreateOperation()
	{
		return new(std::nothrow) COperationDiv();
	}
};

 

main.cpp

// main.cpp : Defines the entry point for the console application.
//

#include "FactoryMethod.h"
#include <iostream>

int main()
{
	//加法运算
	CFactoryAdd FactoryAdd;//减法、乘法、除法等运行，仅在此步骤不同，在此步创建不同的工厂类
	COperation* pOperationAdd = FactoryAdd.CreateOperation();
	if (nullptr != pOperationAdd)
	{
		pOperationAdd->SetNumberA(10);
		pOperationAdd->SetNumberB(5);
		int iResult = pOperationAdd->GetResult();
		std::cout << "运算结果 ： " << iResult << std::endl;
		delete pOperationAdd;
		pOperationAdd = nullptr;
	}

	system("pause");
    return 0;
}

运行结果

工厂方法模式的使用：

工厂方法模式，定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式使一个类的实例化延迟到其子类。

如上面实例，如果要新增一种运算，则需要在实现这种运算的子类，及该运算工厂类的子类。不用像简单工厂模式，要修改工厂类的实现。当然这样的话，需要客户程序修改工厂类创建的地方，创建新的运算工厂即可。

工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户代码来进行。

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户的选择条件动态实例化相关的类，对客户端来说，去除了与具体产品的依赖。

 

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

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

下一篇：设计模式（C++实现）（五）——装饰模式