一个简单的使用宏在预处理阶段实现类反射的功能
1.classFactory
//classFactory.h
#ifndef CLASSFACTORY_H
#define CLASSFACTORY_H
#include <map>
#include <string>
class Obj
{
public:
virtual void show() = 0;
virtual ~Obj() = default;
};
namespace reflect
{
//typedef void* (*create_obj)(void);
using create_obj = Obj* (*) (void);
class ClassFactory
{
public:
void register_class(const std::string& className, create_obj method);
Obj* create_class(const std::string& className);
private:
ClassFactory() = default;
~ClassFactory() = default;
ClassFactory(const ClassFactory&) = delete;
ClassFactory(ClassFactory&&) = delete;
ClassFactory& operator=(const ClassFactory&) = delete;
ClassFactory& operator=(ClassFactory&&) = delete;
public:
static ClassFactory* get_instance()
{
static ClassFactory classFactory;
return &classFactory;
}
private:
std::map<std::string, create_obj> classMap_;
};
}
#endif
//classFactory.cpp
#include "classFactory.h"
void reflect::ClassFactory::register_class(const std::string& className, reflect::create_obj method)
{
classMap_[className] = method;
}
Obj* reflect::ClassFactory::create_class(const std::string& className)
{
auto it = classMap_.find(className);
if (it != classMap_.end())
{
return it->second();
}
return nullptr;
}
2.classRegister.h 和test.h
//register.h
#ifndef CLASS_REGISTER_H
#define CLASS_REGISTER_H
#include "classFactory.h"
class ClassRegister
{
public:
ClassRegister(const std::string& name, reflect::create_obj method)
{
reflect::ClassFactory::get_instance()->register_class(name, method);
}
};
#define REGISTER_CALSS(ClassName)\
Obj* createObj##ClassName()\
{ \
Obj* obj = new ClassName();\
return obj; \
} \
ClassRegister classRegister##ClassName(#ClassName, createObj##ClassName)
#endif // ! CLASS_REGISTER_H
//test.h
#ifndef TEST_H
#define TEST_H
#include <iostream>
#include <string>
#include "classRegister.h"
class A :public Obj
{
public:
A() = default;
~A() = default;
virtual void show() override;
public:
std::string name_;
};
REGISTER_CALSS(A);
inline void A::show()
{
std::cout << "I am A" << std::endl;
}
class B :public Obj
{
public:
B() = default;
~B() = default;
virtual void show() override;
public:
std::string name_;
};
inline void B::show()
{
std::cout << "I am B" << std::endl;
}
REGISTER_CALSS(B);
#endif
4.main.cpp
#include <iostream>
#include "classFactory.h"
#include "test.h"
int main()
{
reflect::ClassFactory* factory = reflect::ClassFactory::get_instance();
Obj* a = factory->create_class("A");
a->show();
Obj* b = factory->create_class("B");
b->show();
return 0;
}