《大话设计模式》C++实现：01 简单工厂模式（优化，使用宏注册工厂）

优化前版本：《大话设计模式》C++实现：01 简单工厂模式

一、代码

1、结果

1.1 main.cpp

#include "Operation.h"
#include "OperationFactory.h"
#include "OperationAdd.h"
#include "OperationSub.h"
#include "OperationMul.h"
#include "OperationDiv.h"

void test()
{
	double numA = 200, numB = 100;
	cout << "A = " << numA << "\tB = " << numB << endl;

	Operation* oper = OperationFactory::instance()->findCreator("OperationAdd");
	oper->setNumberA(numA);
	oper->setNumberB(numB);
	cout << "add result = " << oper->getResult() << endl;

	oper = OperationFactory::instance()->findCreator("OperationSub");
	oper->setNumberA(numA);
	oper->setNumberB(numB);
	cout << "sub result = " << oper->getResult() << endl;

	oper = OperationFactory::instance()->findCreator("OperationMul");
	oper->setNumberA(numA);
	oper->setNumberB(numB);
	cout << "mul result = " << oper->getResult() << endl;

	oper = OperationFactory::instance()->findCreator("OperationDiv");
	oper->setNumberA(numA);
	oper->setNumberB(numB);
	cout << "div result = " << oper->getResult() << endl;
}

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

2、工厂（包括使用宏注册工厂）

2.1 OperationFactory.h

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

/* CDefaultCreaterCleaner */
static Operation *g_default_creater = nullptr;
struct CDefaultCreaterCleaner
{
	inline CDefaultCreaterCleaner() {}
	~CDefaultCreaterCleaner()
	{
		delete g_default_creater;
		g_default_creater = 0;
	}
};

/* OperationFactory */
class OperationFactory
{
public:
	static OperationFactory* instance();
	void registerCreator(string strClassName, Operation *creator);
	Operation* findCreator(string strClassName);
	Operation* defaultCreator();
	void setDefaultCreator(Operation * creator);
private:
	map<string, Operation* > creatorMap;
};
extern OperationFactory* g_pInstance;

#define REGISTER_OBJECT_CREATOR(strName, CreatorClass)\
class CreatorClass##_Register\
{\
public:\
	CreatorClass##_Register()\
	{\
		OperationFactory::instance()->registerCreator(strName, new CreatorClass());\
	}\
};\
static CreatorClass##_Register s_##CreatorClass##_Register;

2.2 OperationFactory.cpp

#include "OperationFactory.h"

OperationFactory* g_pInstance = nullptr;
OperationFactory* OperationFactory::instance()
{
	if (nullptr == g_pInstance)
	{
		g_pInstance = new OperationFactory();
	}
	return g_pInstance;
}

void OperationFactory::registerCreator(string strClassName, Operation *creator)
{
	auto it = creatorMap.find(strClassName);
	if (it != creatorMap.end())
	{
		it->second = creator;
	}
	creatorMap.insert(pair<string, Operation*>(strClassName, creator));
}

Operation* OperationFactory::findCreator(string strClassName)
{
	Operation* pOper = creatorMap[strClassName];
	if (nullptr == pOper)
		return defaultCreator();
	return pOper;
}

Operation* OperationFactory::defaultCreator()
{
	return g_default_creater;
}

void OperationFactory::setDefaultCreator(Operation * creator)
{
	static CDefaultCreaterCleaner cleaner;
	delete g_default_creater;
	g_default_creater = creator;
}

3、四则运算操作类（依次注册）

3.1 Operation.h

#pragma once
#include <iostream>
using namespace std;

class Operation
{
public:
	Operation() {}
	virtual ~Operation() {}
	virtual double getResult() = 0;
	double getNumberA() { return m_numberA; }
	double getNumberB() { return m_numberB; }
	void setNumberA(const double& num) { m_numberA = num; }
	void setNumberB(const double& num) { m_numberB = num; }
protected:
	double m_numberA{ 0 };
	double m_numberB{ 0 };
};

3.2 OperationAdd.h

#pragma once
#include "OperationFactory.h"
class OperationAdd :
	public Operation
{
public:
	OperationAdd() {}
	virtual ~OperationAdd() {}
	double getResult() override { return m_numberA + m_numberB; }
};

REGISTER_OBJECT_CREATOR("OperationAdd", OperationAdd);

3.3 OperationSub.h

#pragma once
#include "OperationFactory.h"

class OperationSub :
	public Operation
{
public:
	OperationSub() {}
	virtual ~OperationSub() {}
	double getResult() override { return m_numberA - m_numberB; }
};
REGISTER_OBJECT_CREATOR("OperationSub", OperationSub);

3.4 OperationMul.h

#pragma once
#include "OperationFactory.h"

class OperationMul :
	public Operation
{
public:
	OperationMul() {}
	virtual ~OperationMul() {}
	double getResult() override { return m_numberA * m_numberB; }
};
REGISTER_OBJECT_CREATOR("OperationMul", OperationMul);

3.5 OperationDiv.h

#pragma once
#include "OperationFactory.h"

class OperationDiv :
	public Operation
{
public:
	OperationDiv() {}
	virtual ~OperationDiv() {}
	double getResult() override 
	{
		double result = 0;
		if (m_numberB == 0)
			throw new std::exception("除数不能为0。");
		result = m_numberA / m_numberB;
		return result;
	}
};
REGISTER_OBJECT_CREATOR("OperationDiv", OperationDiv);