C++ 类对象反射（单例工厂+类注册系统+宏定义）

最终的效果就是可以通过类名的字符串创建相应的类的实例化，话不多说，直接代码展示。

main.cpp：主函数，测试用例

#pragma once
#include <iostream>
#include "ClassFactory.h"
#include "A.h"
using namespace yazi::reflect;
using namespace std;

int main()
{
	ClassFactory* classFactory = Singleton<ClassFactory>::instance();
	Object* a = classFactory->create_class("A");
	cout << "输出为：" << endl;
	a->show();
	system("pause");
	return 0;
}

singleton.h：单例工厂模式

#pragma once

namespace yazi
{

namespace utility
{
template<typename T>
class Singleton
{
public:
	static T* instance() {
		if (m_instance == NULL) {
			m_instance = new T();
		}
		return m_instance;
	}
private:
	Singleton(){}
	Singleton(const Singleton<T>&);
	Singleton<T>& operator =(const Singleton<T>&);
	~Singleton(){}
private:
	static T * m_instance;
};

template<typename T>
T * Singleton<T>::m_instance = NULL;

}

}

ClassFactory.h：类工厂，用于注册和创建类

#pragma once
#include <map>
#include <string>
#include "Singleton.h"


using namespace std;
using namespace yazi::utility;
namespace yazi
{
namespace reflect
{

class Object
{
public:
	Object() {};
	virtual ~Object() {};
	virtual void show() = 0;
};


typedef Object * (* create_object)(void);

class ClassFactory 
{
	friend class Singleton<ClassFactory>;
public:
	void register_class(const string& className, create_object method);
	Object* create_class(const string& className);

private:
	ClassFactory(){}
	~ClassFactory(){}

private:
	map<string, create_object> m_classMap;
};

}
}

ClassFactory.cpp

#pragma once
#include "ClassFactory.h"
using namespace yazi::reflect;


void ClassFactory::register_class(const string& className, create_object method)
{
	m_classMap[className] = method;
}

Object* ClassFactory::create_class(const string& className)
{
	
	auto it = m_classMap.find(className);
	if (it != m_classMap.end()) {
		return it->second();
	}
	return nullptr;
}

ClassRegister.h：类注册，使用宏定义来生成代码，调用类工厂ClassFactory的register_class来注册类。

#pragma once
#include "ClassFactory.h"

#include <string>

using namespace std;

namespace yazi
{

namespace reflect
{


class ClassRegister {
public:
	ClassRegister(const string& className, create_object method)
	{
		Singleton<ClassFactory>::instance()->register_class(className, method);
	}
};	
#define REGISTER_CLASS(className)					\
		Object * createObject##className()			\
		{											\
			Object* obj = new className();			\
			return obj;								\
		}											\
		ClassRegister classRegister##className(#className, createObject##className)

}

}

A.h: 要注册的类，使用宏定义在编译器提前注册好。

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

#include "ClassRegister.h"
using namespace yazi::reflect;

class A : public Object
{
public:
	A() {}
	~A() {}

	void show() {
		cout << number << endl;
	}
private:
	string number = "1";
};

REGISTER_CLASS(A);