## C++反射 ```cpp #include <iostream> #include <unordered_map> #include <memory> #include <functional> class Reflector { public: typedef std::function<void*()> Func; void* CreateObject(const std::string& name) { if (mapFunction_.count(name)) return mapFunction_[name](); return nullptr; } void Regist(const std::string& name, Func&& func) { mapFunction_[name] = func; } static Reflector& Instance() { static Reflector instance; return instance; } private: Reflector() {} std::unordered_map<std::string, Func> mapFunction_; }; class Register { public: typedef std::function<void*()> Func; Register(const std::string& name, Func&& func) { Reflector::Instance().Regist(name, std::forward<Func>(func)); } }; #define REGISTER(class_name) \ Register g_register_##class_name(#class_name, []() { \ return new class_name(); \ }); class Base { public: explicit Base() = default; virtual void Print() { std::cout << "Base" << std::endl; } }; REGISTER(Base); class DeriveA : public Base { public: void Print() override { std::cout << "DeriveA" << std::endl; } }; REGISTER(DeriveA); class DeriveB : public Base { public: void Print() override { std::cout << "DeriveB" << std::endl; } }; REGISTER(DeriveB); #define BASE_CREATE(name) reinterpret_cast<Base*>(Reflector::Instance().CreateObject(name)) int main() { std::shared_ptr<Base> p1(BASE_CREATE("Base")); p1->Print(); std::shared_ptr<Base> p2(BASE_CREATE("DeriveA")); p2->Print(); std::shared_ptr<Base> p3(BASE_CREATE("DeriveB")); p3->Print(); return 0; } ``` 结果： ``` Base DeriveA DeriveB ``` ## 可变参数C++反射 ```cpp /** * @brief C++反射 * @detail 仅支持自定义类型，而且该类型需继承DynamicCreator */ #include <string> #include <iostream> #include <typeinfo> #include <memory> #include <unordered_map> #include <cxxabi.h> #include <functional> namespace neb { class Base { public: Base() {} virtual ~Base() {} virtual void Say() { std::cout << "Base" << std::endl; } }; template <typename... Args> class DynamicFactory { public: static DynamicFactory& Instance() { static DynamicFactory instance; return instance; } bool Regist(const std::string& name, std::function<Base*(Args&&... args)> func) { if (func == nullptr) return false; return mapFunction_.insert(std::make_pair(name, func)).second; } Base* Create(const std::string& name, Args&&... args) { auto iter = mapFunction_.find(name); if (iter == mapFunction_.end()) return nullptr; else return iter->second(std::forward<Args>(args)...); } private: DynamicFactory() {} std::unordered_map<std::string, std::function<Base*(Args&&...)>> mapFunction_; }; template <typename T, typename... Args> class DynamicCreator { public: struct Register { Register() { char* pDemangleName = nullptr; std::string name; pDemangleName = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr); if (pDemangleName != nullptr) { name = pDemangleName; free(pDemangleName); } DynamicFactory<Args...>::Instance().Regist(name, CreateObject); } inline void do_nothing() const {}; }; DynamicCreator() { register_.do_nothing(); } virtual ~DynamicCreator() {}; static T* CreateObject(Args&&... args) { return new T(std::forward<Args>(args)...); } static Register register_; }; template <typename T, typename... Args> typename DynamicCreator<T, Args...>::Register DynamicCreator<T, Args...>::register_; class Cmd : public Base, public DynamicCreator<Cmd> { public: Cmd() { std::cout << "Create Cmd " << std::endl; } virtual void Say() override { std::cout << "I am Cmd" << std::endl; } }; class Step : public Base, public DynamicCreator<Step, std::string, int> { public: Step(const std::string &strType, int iSeq) { std::cout << "Create Step " << strType << " with seq " << iSeq << std::endl; } virtual void Say() override { std::cout << "I am Step" << std::endl; } }; class Reflector { public: template <typename... Args> static std::shared_ptr<Base> Create(const std::string &name, Args &&... args) { std::shared_ptr<Base> ptr(DynamicFactory<Args...>::Instance().Create(name, std::forward<Args>(args)...)); return ptr; } }; } int main(int argc, char** argv) { std::shared_ptr<neb::Base> p1 = neb::Reflector::Create("neb::Cmd"); p1->Say(); std::cout << "----------------------------------------------------------------------" << std::endl; std::shared_ptr<neb::Base> p2 = neb::Reflector::Create("neb::Step", std::string("neb::Step"), 1002); p2->Say(); return 0; } ``` 结果： ``` Create Cmd I am Cmd ---------------------------------------------------------------------- Create Step neb::Step with seq 1002 I am Step ```