【C++设计模式】反射模式

#ifndef __REFLECT_H__
#define __REFLECT_H__

#include <map>
#include <string>

//反射：就是程序在运行的过程中，可以通过类名称创建对象，并获取类中申明的成员变量和方法。

//反射虽然不属于二十三种设计模式，却是很重要的一种机制，C++语言并不支持反射，所以只能通过一些手段模拟实现。

//创建具体类的函数指针
typedef void* (*CreateClassCallback)(void);

class ReflectFactory
{
public:
	static ReflectFactory * GetInstance();  //单例工厂
	
	bool RegisterClass(std::string classname, CreateClassCallback method); //将类名和创建类实例的函数注册到map

	void * GetClassByName(std::string classname);
	
private:
	ReflectFactory(){};
private:
	std::map<std::string, CreateClassCallback> m_classmap;
	static ReflectFactory* m_instance;
};


//通过创建全局对象会调用构造函数完成注册
class RegisterAction
{
public:
	RegisterAction(std::string classname, CreateClassCallback method);
};


//定义注册宏来定义创建类实例的函数，并自动生成一个全局对象
#define REGISTER_CLASS(ClassName)		\
	ClassName * Create##ClassName()		\
	{									\
		return new ClassName();			\
	}									\
	RegisterAction g_Register##ClassName(#ClassName, (CreateClassCallback)Create##ClassName)



//基类
class iBase
{
public:
	iBase(){}
	virtual ~iBase(){}

public:
	virtual void Print() = 0;

};

//具体类
class ClassA : public iBase
{
public:
	ClassA();

	~ClassA();

	void Print();
};


class ClassB : public iBase
{
public:
	ClassB();

	~ClassB();

	void Print();
};


void TestReflect();

#endif

#include "Reflect.h"

ReflectFactory * ReflectFactory::m_instance = NULL;

REGISTER_CLASS(ClassA);

REGISTER_CLASS(ClassB);

ReflectFactory * ReflectFactory::GetInstance()
{
	if(!m_instance)
	{
		m_instance = new ReflectFactory();
	}

	return m_instance;
}

bool ReflectFactory::RegisterClass(std::string classname, CreateClassCallback method)
{
	if(m_classmap.find(classname) == m_classmap.end())
	{
		m_classmap.insert(std::map<std::string, CreateClassCallback>::value_type(classname, method));
		return true;
	}

	return false;
}

void * ReflectFactory::GetClassByName(std::string classname)
{
	std::map<std::string, CreateClassCallback>::iterator it;
	for(it = m_classmap.begin(); it != m_classmap.end(); it++)
	{
		if(it->first == classname)
		{
			return it->second();
		}
	}
	return NULL;
}

RegisterAction::RegisterAction(std::string classname, CreateClassCallback method)
{
	ReflectFactory::GetInstance()->RegisterClass(classname, method);
}

ClassA::ClassA()
{
	printf("create class a\n");
}

ClassA::~ClassA()
{
	printf("destroy class a\n");
}

void ClassA::Print()
{
	printf("Name is ClassA\n");
}

ClassB::ClassB()
{
	printf("create class b\n");
}

ClassB::~ClassB()
{
	printf("destroy class b\n");
}

void ClassB::Print()
{
	printf("Name is ClassB\n");
}


void TestReflect()
{
	ReflectFactory * cf = ReflectFactory::GetInstance();

	iBase * p = (iBase*)cf->GetClassByName("ClassA");

	p->Print();

	delete p;

	p = (iBase*)cf->GetClassByName("ClassB");

	p->Print();

	delete p;
}