抽象工厂方法C++实现

看了设计模式中的抽象工厂方法，书中用到了C#中的反射技术，而C++中没有反射，我就参考MFC中为实现动态创建而设计的DYNCREATE
MACRO的方法来克服抽象工厂的不足。使工厂类完全不更改的情况下就能随意添加新的产品类。工厂类通过读取配置文件动态创建对象。

Utility.h

class COperator;

typedef COperator* (*pCreateFun)();

struct CRuntimeClass
{
char *m_className;
int m_size;
//------used to dynamic create------
COperator *CreateObject();
pCreateFun m_pCreateObj;
//---------------end---------------
static CRuntimeClass *pFirst;
CRuntimeClass *m_pNext;
CRuntimeClass *m_pBase;
};

struct AFX_CLASSINIT
{
AFX_CLASSINIT(CRuntimeClass *pNew);
};

#define DYNCREATE(class_name) \
static CRuntimeClass class##class_name; \
static COperator *CreateObject();

#define _IMPLEMENT_DYNCREATE(class_name, base_class_name)
\
static char name##class_name[] = #class_name; \
CRuntimeClass class_name::class##class_name = {\
name##class_name, sizeof(class_name),
class_name::CreateObject, \
CRuntimeClass::pFirst,
&base_class_name::class##base_class_name};\
static AFX_CLASSINIT
_init_##class_name(&class_name::class##class_name);\
COperator *class_name::CreateObject() \
{\
return new class_name; \
}\

#define IMPLEMENT_DYNCREATE(class_name, base_class_name)
\
_IMPLEMENT_DYNCREATE(class_name,
base_class_name) 

COperator.h

#include
#include "Utility.h"

class COperator
{
public:
COperator();
void setNum(int a1, int a2);
virtual int GetResult();
public:
DYNCREATE(COperator);
protected:
int num1;
int num2;
};

class CAddOperator : public COperator
{
public:

CAddOperator() : COperator()
{}
int GetResult()
{
return num1 + num2;
}
DYNCREATE(CAddOperator)
};

class CSubOperator : public COperator
{
public:
CSubOperator() : COperator()
{}
int GetResult()
{
return num1 - num2;
}
DYNCREATE(CSubOperator)
};

class CMulOperator : public COperator
{
public:
CMulOperator() : COperator()
{}
int GetResult()
{
return num1 * num2;
}
DYNCREATE(CMulOperator)
};

class CDivOperator : public COperator
{
public:
CDivOperator() : COperator()
{}
int GetResult()
{
return num1 / num2;
}
DYNCREATE(CDivOperator);
};

class CPowerOperator : public COperator
{
public:
CPowerOperator() : COperator()
{}
int GetResult()
{
return std::pow(num1, num2);
}
DYNCREATE(CPowerOperator);
};

COperator.cpp

#include "COperator.h"

int COperator::GetResult()
{
//it isn't implement it
return 0;
}

COperator::COperator()
{
}

void COperator::setNum(int a1, int a2)
{
num1 = a1;
num2 = a2;
}

AFX_CLASSINIT::AFX_CLASSINIT(CRuntimeClass *pNew)
{
pNew->m_pNext = CRuntimeClass::pFirst;
CRuntimeClass::pFirst = pNew;
}

CRuntimeClass COperator::classCOperator = {
"COperator", sizeof(COperator), COperator::CreateObject,
NULL, NULL};

CRuntimeClass *CRuntimeClass::pFirst =
&COperator::classCOperator;

COperator *COperator::CreateObject()
{
return new COperator();
}

COperator *CRuntimeClass::CreateObject()
{ 
return (*m_pCreateObj)();
}

//运用很优雅的方式就解决了产品扩展的问题，也克服了简单工厂中的switch case的不足
//so elegant!
IMPLEMENT_DYNCREATE(CAddOperator, COperator)
IMPLEMENT_DYNCREATE(CSubOperator, COperator)
IMPLEMENT_DYNCREATE(CMulOperator, COperator)
IMPLEMENT_DYNCREATE(CDivOperator, COperator)
IMPLEMENT_DYNCREATE(CPowerOperator, COperator)

SimFactory.h

#include "COperator.h"
#include

class CSimFactory
{
public:
static COperator *CreateOperator()
{
char name[20];
memset(name, '\0', 20);
std::ifstream ofile;
ofile.open("config.ini", std::ios_base::binary);
ofile.getline(name, 20);
ofile.close();

for(CRuntimeClass *p = CRuntimeClass::pFirst; p != NULL; p =
p->m_pNext)
{
if(0 == strcmp(p->m_className, name))
return p->CreateObject();
}
return NULL;
}
};

config.ini
CPowerOperator

main.cpp

#include "SimFactory.h"
#include
int main()
{
int a1, a2;

std::cin>>a1>>a2;

COperator *ptr = CSimFactory::CreateOperator();
if(NULL != ptr)
{
ptr->setNum(a1, a2);
std::cout<<"The result is
"<<ptr->GetResult()<<std::endl;
}
if(NULL!= ptr)
delete ptr;
return 0;
}

如果你想扩展操作符类，例如添加立方运算，你只需要设计一个CCube类，让它继承COPerator类，在CCube类中添加MACRO DYNCREATE(CCube)，
在实现文件中添加MACRO IMPLEMENT_DYNCREATE(CCube,
COperator)即可完美解决问题。
虽然说提倡在C++的设计中最好完全放弃MACRO，不得不说，有时运用MACRO能达到一些巧妙的设计。