《大话设计模式》C++实现：08 工厂模式

1. 什么是工厂模式？

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

2. 工厂模式的适用场景？

2.1 优缺点

优势：
克服了简单工厂方式违背的"开放-封闭原则"（简单工厂不但对扩展开放了，对修改也开放了），工厂方法，最起码对修改封装了起来，降低了客户程序对产品对象的耦合。
工厂方法模式就是简单工厂模式的进一步抽象和推广。
弊端：
1、由于每增加一个产品，就需要加一个产品工厂的类，增加了额外的开发量。
2、需要客户端决定实例化哪一个具体工厂，选择判断问题依然存在，只是将简单工厂的内部逻辑判断转移到了客户端代码进行，想要加功能，本来修改工厂类，现在修改客户端，
如何规避工厂方法的弊端？
利用"反射"可以避免分支判断的问题，具体优化见：抽象工厂模式之反射的应用（待续）。

3. 怎样使用工厂模式？

3.1 方法

使用"依赖倒转原则"，解耦工厂类与分支：
step1：把工厂类抽象出一个接口，这个接口只有一个方法，就是创建抽象产品的工厂方法。
step2：所有要生产具体类的工厂，都继承工厂基类，并去实现这个接口；
这样，一个简单工厂模式的工厂类，就变成了一个工厂抽象接口和多个具体生成对象的工程。
eg：当我们需要添加"幂运算"功能时，就无需更改原有的工厂类了，只需增加此功能的运算类和相应的工厂类即可。

3.2 UML类图

4. 实例

4.1 结果（结论先行）

#include <iostream>
#include "AddFactory.h"
#include "SubFactory.h"
#include "MulFactory.h"
#include "DivFactory.h"

#include "Operation.h"
using namespace std;

void test0()
{
	//=============加=================
	IFactory* pFactory = new AddFactory();
	Operation* pOper = pFactory->createOperation();
	pOper->setNumberA(20);
	pOper->setNumberB(10);
	cout << "A = " << pOper->getNumberA() << ",\tB = " << pOper->getNumberB() << endl;
	cout << "add result = " << pOper->getResult() << endl;
	//=============减=================
	pOper = (new SubFactory())->createOperation();
	pOper->setNumberA(20);
	pOper->setNumberB(10);
	cout << "div result = " << pOper->getResult() << endl;
	//=============乘=================
	pOper = (new MulFactory())->createOperation();
	pOper->setNumberA(20);
	pOper->setNumberB(10);
	cout << "mul result = " << pOper->getResult() << endl;
	//=============除=================
	pOper = (new DivFactory())->createOperation();
	pOper->setNumberA(20);
	pOper->setNumberB(10);
	cout << "div result = " << pOper->getResult() << endl;
	
	delete pFactory;
	delete pOper;
	pFactory = nullptr;
	pOper = nullptr;
}

int main()
{
	test0();
	system("pause");
	return 0;
}

4.2 具体实现：工厂继承体系函数接口

4.2.1 IFactory.h

#pragma once
#include "Operation.h"
class IFactory
{
public:
	IFactory() {}
	virtual ~IFactory() {}
	virtual Operation* createOperation() = 0;
};

4.2.2 AddFactory.h

#pragma once
#include "IFactory.h"
#include "OperationAdd.h"
class AddFactory :
	public IFactory
{
public:
	AddFactory() :IFactory() {}
	virtual ~AddFactory() {}
	virtual Operation* createOperation() override
	{
		return new OperationAdd();
	}
};

4.2.3 SubFactory.h

#pragma once
#include "IFactory.h"
#include "OperationSub.h"

class SubFactory :
	public IFactory
{
public:
	SubFactory() {}
	virtual ~SubFactory() {}
	virtual Operation* createOperation() override
	{
		return new OperationSub();
	}
};

4.2.4 MulFactory.h

#pragma once
#include "IFactory.h"
#include "OperationMul.h"

class MulFactory :
	public IFactory
{
public:
	MulFactory() :IFactory() {}
	virtual ~MulFactory() {}
	virtual Operation* createOperation() override
	{
		return new OperationMul();
	}
};

4.2.5 DivFactory.h

#pragma once
#include "IFactory.h"
#include "OperationDiv.h"

class DivFactory :
	public IFactory
{
public:
	DivFactory() :IFactory() {}
	virtual ~DivFactory() {}
	virtual Operation* createOperation() override
	{
		return new OperationDiv();
	}
};

4.3 具体实现：计算器继承体系函数接口

4.2.1 Operation.h

#pragma once
class Operation
{
public:
	Operation() {}
	virtual ~Operation() {}
	virtual double getResult() = 0;
	void setNumberA(double a) { m_nNumberA = a; }
	void setNumberB(double b) { m_nNumberB = b; }
	double getNumberA() { return m_nNumberA; }
	double getNumberB() { return m_nNumberB; }
protected:
	double m_nNumberA;
	double m_nNumberB;
};

4.3.2 OperationAdd.h

#pragma once
#include "Operation.h"
class OperationAdd :
	public Operation
{
public:
	OperationAdd() :Operation() {}
	virtual ~OperationAdd() {}

	virtual double getResult() override
	{
		return m_nNumberA + m_nNumberB;
	}
};

4.3.3 OperationSub.h

#pragma once
#include "Operation.h"
class OperationSub :
	public Operation
{
public:
	OperationSub() :Operation() {}
	virtual ~OperationSub() {}

	virtual double getResult() override
	{
		return m_nNumberA - m_nNumberB;
	}

};

4.3.4 OperationMul.h

#pragma once
#include "Operation.h"
class OperationMul :
	public Operation
{
public:
	OperationMul() :Operation() {}
	virtual ~OperationMul() {}

	virtual double getResult() override
	{
		return m_nNumberA * m_nNumberB;
	}

};

4.3.5 OperationDiv.h

#pragma once
#include "Operation.h"
#include <iostream>
using namespace std;

class OperationDiv :
	public Operation
{
public:
	OperationDiv() :Operation() {}
	~OperationDiv() {}

	virtual double getResult() override
	{
		if (m_nNumberB == 0)
		{
			cout << "分母为0，返回0" << endl;
			return 0;
		}
		return m_nNumberA / m_nNumberB;
	}
};

此为《大话设计模式》学习心得系列 P69~~