设计模式-工厂方法模式

工厂方法模式： 

    我对这个的理解是，简单工厂的工厂是生产对象，而工厂方法模式的工厂是生产工厂对象，然后被生产的工厂对象再去生产产品对象，也就是把对象的创建延迟到了工厂创建的工厂里。要理解这个模式就要对比着去看简单工厂，还有就是书上对这个例子描述的不是很透彻，用的例子没说明性，也没过多的阐述这个模式的特点，也就是书上说的不是很透，我看了书然后又在网上查了一些资料，现在我还是用例子说明（我之前的总结有问题，这次重新总结）。
还是来分析加减乘除的那个问题，简单工厂方法是把算法抽象出来，然后通过工厂直接生产算法类实体，然后客户端得到这个类直接调用。看上去还比较简单，但是问题是不满足OCP啊，就是那个工厂里面的那个Switch（），为了解决掉这个问题，工厂方法是在工厂的地方继续抽象，当新增加一个算法的时候，直接增加一个继承类就行了。这样满足OCP，方便扩展。

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

    简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。而工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单的工厂的内部逻辑哦判断移到了客户端代码来进行，你想要加功能，本来是改工厂类的么人现在是修改客户端！。但是最大的优点就是扩展的时候可以满足OCP了。

工厂方法模式实现加减乘除：

#pragma once
//抽象算法接口
class CInterfaceAlgorithm
{
public:
	virtual bool GetValue(const int &nNumberA ,const int &nNumberB ,int &nNumberAns) = 0;
};

class CAddition : public CInterfaceAlgorithm
{
public:
	bool GetValue(const int &nNumberA ,const int &nNumberB ,int &nNumberAns)
	{
		nNumberAns = nNumberA + nNumberB;
		return true;
	}
};

class CSubtraction : public CInterfaceAlgorithm
{
public:
	bool GetValue(const int &nNumberA ,const int &nNumberB ,int &nNumberAns)
	{
		nNumberAns = nNumberA - nNumberB;
		return true;
	}
}; 

class CMultiplication : public CInterfaceAlgorithm
{
public:
	bool GetValue(const int &nNumberA ,const int &nNumberB ,int &nNumberAns)
	{
		nNumberAns = nNumberA * nNumberB;
		return true;
	}
}; 

class CDivision : public CInterfaceAlgorithm
{
public:
	bool GetValue(const int &nNumberA ,const int &nNumberB ,int &nNumberAns)
	{
		if(!nNumberB)
		{
			return false;
		}
		nNumberAns = nNumberA / nNumberB;
		return true;
	}
}; 

//工厂接口
class CInterfaceFactory
{
public:
	virtual CInterfaceAlgorithm * GetFactoryBody() = 0;
};

class CAdditionFactory : public CInterfaceFactory
{
public:
	CInterfaceAlgorithm * GetFactoryBody()
	{
		return new CAddition();
	}
};

class CSubtractionFactory : public CInterfaceFactory
{
public:
	CInterfaceAlgorithm * GetFactoryBody()
	{
		return new CSubtraction();
	}
};

class CMultiplicationFactory : public CInterfaceFactory
{
public:
	CInterfaceAlgorithm * GetFactoryBody()
	{
		return new CMultiplication();
	}
};

class CDivisionFactory : public CInterfaceFactory
{
public:
	CInterfaceAlgorithm * GetFactoryBody()
	{
		return new CDivision();
	}
};

客户端调用：

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

int main()
{
	CInterfaceAlgorithm *pHashMemoryAlgorithm[10] = {0};
	CInterfaceFactory *pHashMemoryFactory[10] = {0};
	int nAlgorithmId = -1 ,nFactoryId = -1 ,nAns;
	
	pHashMemoryFactory[++nFactoryId] = new CAdditionFactory();
	pHashMemoryAlgorithm[++nAlgorithmId] = pHashMemoryFactory[nFactoryId]->GetFactoryBody();

	pHashMemoryFactory[++nFactoryId] = new CSubtractionFactory();
	pHashMemoryAlgorithm[++nAlgorithmId] = pHashMemoryFactory[nFactoryId]->GetFactoryBody();

	pHashMemoryFactory[++nFactoryId] = new CMultiplicationFactory();
	pHashMemoryAlgorithm[++nAlgorithmId] = pHashMemoryFactory[nFactoryId]->GetFactoryBody();

	pHashMemoryFactory[++nFactoryId] = new CDivisionFactory();
	pHashMemoryAlgorithm[++nAlgorithmId] = pHashMemoryFactory[nFactoryId]->GetFactoryBody();

	for(int i = 0 ;i <= nAlgorithmId ;i ++)
	{
		if( pHashMemoryAlgorithm[i]!= NULL && pHashMemoryAlgorithm[i]->GetValue(1 ,5 ,nAns))
		{
			cout<<nAns<<endl;
		}
		else 
		{
			cout<<"Error"<<endl;
		}
	}

	for(int i = 0 ;i <= nAlgorithmId ;i ++)
	{
		delete pHashMemoryAlgorithm[i];
		delete pHashMemoryFactory[i];
	}
	return 0;
}