抽象工厂方法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能达到一些巧妙的设计。