简单工厂组合策略模式_反射

#include <iostream>
#include <map>

using namespace std;

typedef void* (*CreateClass)(int,int);

#define DECLARE_CLASS(className)\
static CKDynamicClass *className##dc;

#define IMPLEMENT_CLASS(c,className)\
CKDynamicClass* className::className##dc=\
new CKDynamicClass(c,className::CreateInstance);

class CClassFactory
{
private:
map<char,CreateClass>   m_mapMethod;
public:
void* GetClassByType(char cType,int nFirst,int nSecond)
{
map<char,CreateClass>::const_iterator iter;
iter=m_mapMethod.find(cType);
if(iter!=m_mapMethod.end())
return iter->second(nFirst,nSecond);
else
return NULL;
}

void RegisterMethod(char cType,CreateClass method)
{
m_mapMethod.insert(pair<char,CreateClass>(cType,method));
}

static CClassFactory& GetInstance()
{
static CClassFactory classFactory;
return classFactory;
}
};

class CKDynamicClass
{
public:
CKDynamicClass(char cType,CreateClass method)
{
CClassFactory::GetInstance().RegisterMethod(cType,method);
}
};

class COperation
{
protected:
int m_nFirst;
int m_nSecond;
public:
COperation(int nFirst,int nSecond)
:m_nFirst(nFirst),m_nSecond(nSecond)
{}

virtual double GetResult()=0;
};

class CContext
{
private:
COperation *m_classOper;
public:
CContext(char cType,int nFirst,int nSecond)
{
m_classOper=(COperation*)CClassFactory::GetInstance().GetClassByType(cType,nFirst,nSecond);
}

double GetResult()
{
double dResult=0.0;
if(m_classOper!=NULL)
dResult=m_classOper->GetResult();
return dResult;
}
};

class CAddOperation:public COperation
{
private:
DECLARE_CLASS(CAddOperation)
public:
CAddOperation(int nFirst,int nSecond)
:COperation(nFirst,nSecond)
{}

static void* CreateInstance(int nFirst,int nSecond)
{
return new CAddOperation(nFirst,nSecond);
}

virtual double GetResult()
{
return m_nFirst+m_nSecond;
}
};

IMPLEMENT_CLASS('+',CAddOperation)

class CSubOperation:public COperation
{
private:
DECLARE_CLASS(CSubOperation)
public:
CSubOperation(int nFirst,int nSecond)
:COperation(nFirst,nSecond)
{}

static void* CreateInstance(int nFirst,int nSecond)
{
return new CSubOperation(nFirst,nSecond);
}

virtual double GetResult()
{
return m_nFirst-m_nSecond;
}
};

IMPLEMENT_CLASS('-',CSubOperation)

/********扩展***************/
class CMulOperation:public COperation
{
private:
DECLARE_CLASS(CMulOperation)
public:
CMulOperation(int nFirst,int nSecond)
:COperation(nFirst,nSecond)
{}

static void* CreateInstance(int nFirst,int nSecond)
{
return new CMulOperation(nFirst,nSecond);
}

virtual double GetResult()
{
return m_nFirst*m_nSecond;
}
};
IMPLEMENT_CLASS('*',CMulOperation)
/************************************/

int main(void)
{
char c;
cin>>c;
CContext *pContext=new CContext(c,4,3);
cout<<pContext->GetResult()<<endl;
system("pause");
return 0;
}