C++实现反射机制

  1. #define DECLARE_CLASS_CREATE(class_name) \  
    
    static CObject* CreateClass## class_name ();  
    
      
    #define IMPL_CLASS_CREATE(class_name) \  
      
    static CObject* CreateClass## class_name (){ \  
      
    return new class_name; \  
      
    };  
      
      
    #define REG_CLASS_CREATE(class_name) \  
      
    RegisterFactoryCreate(class_name::CreateClass## class_name, #class_name);  
    

  2. C++并不支持反射机制,只能自己实现。

    如果需要实现字字符串到函数到映射,一定要使用到函数指针

    简单实现反射机制,根据字符串来构造相应到类。主要有以下几点:

    (1) 可以使用map保存字符从到函数指针到映射。

    (2) 工厂类提供字符串与函数指针到注册关系。

    (3) 工厂模式根据不同到字符串构造不同到类对象。

  3. #ifndef __CLASSFACTORY_
    #define __CLASSFACTORY_
    
    #include <iostream>
    #include<string>
    #include<map>
    
    //定义函数指针
    typedef void* (*create_fun)();
    
    class ClassFactory{
    public:
        ~ClassFactory() {}; 
    
        //根据类注册时的名字, 创建类实例, 并返回
        void* getClassByName(std::string name){
            std::map<std::string, create_fun>::iterator it = my_map.find(name);
            if (it == my_map.end()) { return NULL; }
    
            create_fun fun = it->second;
            if (!fun) { return NULL; }
    
            return fun();
        }   
    
        //注册类名称与指针函数到映射关系
        void registClass(std::string name, create_fun fun){
            my_map[name] = fun;
        }   
    
        //单例模式
        static ClassFactory& getInstance(){
            static ClassFactory fac;
            return fac;
        }   
    
    private:
        ClassFactory() {};  //私有
        std::map<std::string, create_fun> my_map;
    }; 
    
    #endif
    
    
    
    
    
    #ifndef __TEST_H
    #define __TEST_H
    
    #include <iostream>
    
    class Test{
    public:
        Test(){ std::cout << "call Test Constructor fun" << std::endl; }
        ~Test(){ std::cout << "call Test Destructor fun" << std::endl; }
        void print(){ std::cout << "call Test print fun" << std::endl; }
    };
    
    void* create_Test(){
        Test *t = new Test;
        return (t == NULL)? NULL:t;
    }
    
    #endif
    
    
    
    #include "test.h"
    #include "class_factory.h"
    
    int main(){
        //注册
        ClassFactory::getInstance().registClass("Test", create_Test);
    
        //获取类对象
        Test *t = (Test*)ClassFactory::getInstance().getClassByName("Test");
        if (!t){
            std::cout << "get instnce Test err;" << std::endl;
            return 1;
        }   
        
        t->print();
        delete t;
        return 0;
    }


  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
反射机制是一种编程语言的特性,它允许程序在运行时获取类的信息并在运行时动态地创建对象、调用方法等。在C++中,反射机制需要通过元编程技术实现,下面是一份简单的C++反射机制代码示例: ```c++ #include <iostream> #include <string> #include <map> #include <functional> // 定义一个基类 class Base { public: virtual void print() const { std::cout << "Base" << std::endl; } }; // 定义一个派生类 class Derived : public Base { public: void print() const override { std::cout << "Derived" << std::endl; } }; // 定义一个反射类 template <typename T> class Reflector { public: // 注册类型信息 static void registerType(const std::string& name) { typeMap()[name] = []() -> Base* { return new T(); }; } // 创建对象 static Base* create(const std::string& name) { auto it = typeMap().find(name); if (it != typeMap().end()) { return it->second(); } else { return nullptr; } } private: // 类型名称和构造函数的映射表 static std::map<std::string, std::function<Base*()>>& typeMap() { static std::map<std::string, std::function<Base*()>> s_typeMap; return s_typeMap; } }; // 注册类型信息 static int dummy = (Reflector<Base>::registerType("Base"), Reflector<Derived>::registerType("Derived"), 0); int main() { // 创建对象 Base* b = Reflector<Base>::create("Base"); if (b) { b->print(); delete b; } Base* d = Reflector<Base>::create("Derived"); if (d) { d->print(); delete d; } return 0; } ``` 在上述示例中,我们定义了一个基类Base和一个派生类Derived,然后定义了一个Reflector反射类,用于注册类型信息和创建对象。具体步骤如下: 1. 在Reflector类中定义一个静态成员函数registerType,用于注册类型信息。我们使用std::map来维护类型名称和构造函数的映射关系,将构造函数封装成std::function类型,方便调用。 2. 在Reflector类中定义一个静态成员函数create,用于创建对象。我们在typeMap中查找类型名称对应的构造函数,并调用它来创建对象。 3. 在主函数中,我们先使用Reflector<Base>::create来创建一个Base对象,并调用它的print方法。然后使用Reflector<Base>::create来创建一个Derived对象,并调用它的print方法。 4. 在程序中其他地方,我们可以通过Reflector类来注册更多的类型信息,并动态地创建对象。 需要注意的是,在实际的编程中,我们还需要考虑类型的安全性和可扩展性等问题,上述示例仅仅是一个简单的反射机制实现
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值