设计模式之工厂方法模式（C++）

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

这里要区分一下工厂方法模式与简单工厂模式的区别。简单工厂模式需要在工厂类中判断要生产什么类型的对象。工厂方法模式则把这部分工作交给了客户端。每一种类对象都有自己的工厂，客户端根据自己的不同需要生成不同工厂，然后在生产自己需要的对象。工厂方法模式相对简单工厂模式来说降低了类与客户端的耦合度。最重要的一点是当需要添加其他的类的时候不用修改原来的代码。只需用添加响应的工厂就行了和类就行了。这样做遵循了开放-封闭原则。而简单工厂模式实际是破坏了开放-封闭原则。

其代码如下：

// FactoryMethodModel.h文件
#pragma once
#include <iostream>
// 操作类
template<typename T>
class Operation
{
public:
	Operation(const T &lpa, const T &rpa)
	{
		this->lpa = lpa;
		this->rpa = rpa;
	}
	virtual T getResult() = 0;
protected:
	T lpa, rpa;
};
//加法操作
template<typename T>
class AddOperation : public Operation<T>
{
public:
	AddOperation(const T lpa, const T rpa) : Operation<T>(lpa, rpa)
	{
		;
	}
	virtual T getResult()
	{
		return this->lpa + this->rpa;
	}
};
// 减法操作
template<typename T>
class SubOperation : public Operation<T>
{
public:
	SubOperation(const T lpa, const T rpa) : Operation<T>(lpa, rpa)
	{
		;
	}
	virtual T getResult()
	{
		return this->lpa - this->rpa;
	}
};
// 乘法操作
template<typename T>
class MulOperation : public Operation<T>
{
public:
	MulOperation(const T lpa, const T rpa) : Operation<T>(lpa, rpa)
	{
		;
	}
	virtual T getResult()
	{
		return this->lpa * this->rpa;
	}
};
// 除法操作
template<typename T>
class DivOperation : public Operation<T>
{
public:
	DivOperation(const T lpa, const T rpa) : Operation<T>(lpa, rpa)
	{
		;
	}
	virtual T getResult()
	{
		if (0 == this->rpa)
		{
			std::cout << "除数不能为0" << std::endl;
			return 0;
		}
		return this->lpa / this->rpa;
	}
};
// 工厂类
template<typename T>
class Factory
{
public:
	virtual Operation<T> * createObject(const T &lpa, const T &rpa) = 0;
};
// 加法工厂
template<typename T>
class AddFactory : public Factory<T>
{
public:
	virtual Operation<T> * createObject(const T &lpa,const T &rpa)
	{
		return new AddOperation<T>(lpa, rpa);
	}
};
// 减法工厂
template<typename T>
class SubFactory : public Factory<T>
{
public:
	virtual Operation<T> * createObject(const T &lpa, const T &rpa)
	{
		return new SubOperation<T>(lpa, rpa);
	}
};
// 乘法工厂
template<typename T>
class MulFactory : public Factory<T>
{
public:
	virtual Operation<T> * createObject(const T &lpa, const T &rpa)
	{
		return new MulOperation<T>(lpa, rpa);
	}
};
// 除法工厂
template<typename T>
class DivFactory : public Factory<T>
{
public:
	virtual Operation<T> * createObject(const T &lpa,const T &rpa)
	{
		return new DivOperation<T>(lpa, rpa);
	}
};

测是代码如下：

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

int main()
{
	using namespace std;
	// 工厂方法模式,与简单工厂模式的区别就是简单工厂模式中需要由工厂
	// 来判断生成什么类型的Operation，而工厂方法模式则由客户端来判断
	// 需要什么类型的操作则创建什么样的工厂，这样耦合度更低。添加类型
	// 方法类型的时候不用修改原来的代码，遵从了开放-封闭原则。
	double a = 1384.348, b = 109348.9785234;

	Factory<double> *p = new AddFactory<double>;
	Operation<double> * oper = p->createObject(a, b);
	double d = oper->getResult();
	cout << oper->getResult() << endl;
	delete oper;
	delete p;

	p = new SubFactory<double>;
	oper = p->createObject(a, b);
	cout << oper->getResult() << endl;
	delete oper;
	delete p;

	p = new MulFactory<double>;
	oper = p->createObject(a, b);
	cout << oper->getResult() << endl;
	delete oper;
	delete p;

	p = new DivFactory<double>;
	oper = p->createObject(a, b);
	cout << oper->getResult() << endl;
	delete oper;
	delete p;
	
	getchar();
	return 0;
}

测试结果如下图：