C++反射实现

C++实现反射的一个简单实验，考虑并不充分。 

typelist.h

#ifndef _TYPELIST_H
#define _TYPELIST_H
class NullType {};

//Typelist
template <class T, class U>
struct Typelist
{
   typedef T Head;
   typedef U Tail;
};
template <class TList, class T> struct IndexOf;
        
template <class T>
struct IndexOf<NullType, T>
{
   enum { value = -1 };
};
        
template <class T, class Tail>
struct IndexOf<Typelist<T, Tail>, T>
{
   enum { value = 0 };
};
        
template <class Head, class Tail, class T>
struct IndexOf<Typelist<Head, Tail>, T>
{
   private:
       enum { temp = IndexOf<Tail, T>::value };
   public:
       enum { value = (temp == -1 ? -1 : 1 + temp) };
};
#define LOKI_TYPELIST_1(T1) Typelist<T1, NullType>
#define LOKI_TYPELIST_2(T1, T2) Typelist<T1, LOKI_TYPELIST_1(T2) >
#define LOKI_TYPELIST_3(T1, T2, T3) Typelist<T1, LOKI_TYPELIST_2(T2, T3) >
#define LOKI_TYPELIST_4(T1, T2, T3, T4) /
    Typelist<T1, LOKI_TYPELIST_3(T2, T3, T4) >
#define LOKI_TYPELIST_5(T1, T2, T3, T4, T5) /
    Typelist<T1, LOKI_TYPELIST_4(T2, T3, T4, T5) >
#define LOKI_TYPELIST_6(T1, T2, T3, T4, T5, T6) /
    Typelist<T1, LOKI_TYPELIST_5(T2, T3, T4, T5, T6) >
#define LOKI_TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) /
    Typelist<T1, LOKI_TYPELIST_6(T2, T3, T4, T5, T6, T7) >
#define LOKI_TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) /
    Typelist<T1, LOKI_TYPELIST_7(T2, T3, T4, T5, T6, T7, T8) >
#define LOKI_TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) /
    Typelist<T1, LOKI_TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9) >
#define LOKI_TYPELIST_10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) /
    Typelist<T1, LOKI_TYPELIST_9(T2, T3, T4, T5, T6, T7, T8, T9, T10) >
#define LOKI_TYPELIST_11(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) /
    Typelist<T1, LOKI_TYPELIST_10(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) >
#define LOKI_TYPELIST_12(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) /
    Typelist<T1, LOKI_TYPELIST_11(T2, T3, T4, T5, T6, T7, T8, T9, T10, /
        T11, T12) >
#define LOKI_TYPELIST_13(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,T13) /
    Typelist<T1, LOKI_TYPELIST_12(T2, T3, T4, T5, T6, T7, T8, T9, T10, /
        T11, T12, T13) >
#define LOKI_TYPELIST_14(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,T13,T14) /
    Typelist<T1, LOKI_TYPELIST_13(T2, T3, T4, T5, T6, T7, T8, T9, T10, /
        T11, T12, T13,T14) >
template<int v>
struct Int2Type
{
    enum {value = v};
};
#endif

 

any.h

 

#ifndef _ANY_H
#define _ANY_H
#include <vector>
//#include "TypeList.h"
//#include "Trait.h"
//一个精简版的boost::any
class any
{
public: // structors
   any(): content(0),counter(0)
   {
   }
   template<typename ValueType>
   any(const ValueType & value)
      : content(new holder<ValueType>(value)),counter(new int(1))
   {
   }
   any(const any & other)
   {
       if(other.counter && other.content)
       {
           content = other.content;
           counter = other.counter;
           ++(*counter);
       }
       else
       {
           content = 0;
           counter = 0;
       }
   }
       any & operator=(const any & rhs)
    {
        if(&rhs == this)
            return *this;
        else
        {      
            _destroy();
            if(rhs.counter && rhs.content)
            {
                content = rhs.content;
                counter = rhs.counter;
                ++(*counter);
            }
            else
            {
                content = 0;
                counter = 0;
            }
            return *this;
        }
    }
   ~any()
   {
        _destroy();
   }
private:
    void _destroy()
    {
        if(counter && content && --*counter <= 0)
        {
            delete counter;
            delete content;
        }
    }
public: // queries
    bool empty() const
    {
       return !content;
    }
public:
    class placeholder
    {
      public: // structors
        virtual ~placeholder()
        {
        }
     };
     template<typename ValueType>
     class holder : public placeholder
     {
       public: // structors
         holder(const ValueType & value)
           : held(value)
         {
         }
       public: // representation
          ValueType held;
      };
public: // representation (public so any_cast can be non-friend)
   placeholder * content;
   int         * counter;
};
template<typename ValueType>
inline ValueType any_cast(const any & operand)
{
    any::holder<ValueType> * tmp = static_cast<any::holder<ValueType> *>(operand.content);
    return tmp->held;
}
#endif

 

reflect.h

#ifndef _REFLECT_H
#define _REFLECT_H

#include "any.h"
#include <string>
#include <map>




class Value
{
public:
    Value(const any &value):_value(value){}

    Value(const Value &other):_value(other._value)
    {
        
    }

    Value & operator=(const Value & rhs)
    {
        if(&rhs == this)
            return *this;
        else
        {
            _value = rhs._value;
            return *this;
        }
    }

    const any& GetValue() const
    {
        return _value;
    }

    void SetValue(const any &value)
    {
        _value = value;
    }

private:
    any _value;
};

class reflectBase;

struct attribute_op
{
    typedef Value (reflectBase::*func_get)();
    typedef void (reflectBase::*func_set)(const Value&);

    func_get _get;
    func_set _set;

};


class Attribute
{

public:    

    Attribute(){}

    Attribute(const std::string &name,attribute_op &op)
        :name(name),member_get(op._get),member_set(op._set)
    {}
    

    Value GetValue(reflectBase &object)
    {
        return (object.*member_get)();

    }

    void  SetValue(reflectBase &object,const Value &value)
    {
        (object.*member_set)(value);
    }

    const std::string &GetName()
    {
        return name;
    }

    ~Attribute()
    {
    }

private:
    std::string name;

    attribute_op::func_get member_get;
    attribute_op::func_set member_set;
};

class param
{
public:

    param(){}

    param(const any& p1)
    {
        m_param.push_back(p1);
    }

    param(const any& p1,const any &p2)
    {
        m_param.push_back(p1);
        m_param.push_back(p2);
    }


    std::vector<Value> m_param;
};


struct memberFunc_op
{
    typedef Value (reflectBase::*func)(const param &);
    func _call;
};


class reflectBase;

class memberFunction
{
public:

    typedef memberFunc_op::func methord;

    memberFunction(const std::string &name,memberFunc_op &op)
        :funcname(name),_call(op._call)//,callret(op._call_ret)
    {}

    methord GetMethord()
    {
        return _call;
    }
    
    ~memberFunction()
    {
    }
public:
    std::string funcname;

    memberFunc_op::func _call;
};

class classdef;

class reflectBase
{
public:
    virtual classdef    *GetClassDef() = 0;
    virtual ~reflectBase(){};
};


class classdef
{
public:

    typedef reflectBase* (*creator)();

    classdef(const std::string& name,classdef::creator _creator):classname(name),instance_creator(_creator){} 

    reflectBase *CreateInstance()
    {
        return instance_creator();
    }
    
    void AddAttribute(const std::string &name,Attribute *attr)
    {
        attributes.insert(std::make_pair(name,attr));
    }

    void AddMemberFunc(const std::string &name,memberFunction *func)
    {
        memberfuncs.insert(std::make_pair(name,func));
    }

    memberFunction *GetMemFunc(const std::string &name)
    {
        std::map<std::string,memberFunction*>::iterator it = memberfuncs.find(name);
        if(it != memberfuncs.end())
            return it->second;
        return NULL;
    }

    Attribute* FindAttribute(const std::string &name)
    {
        std::map<std::string,Attribute*>::iterator it = attributes.find(name);
        if(it != attributes.end())
            return it->second;
        return NULL;
    }


public:
    std::string classname;
    std::map<std::string,Attribute*> attributes;
    std::map<std::string,memberFunction*> memberfuncs;
    creator instance_creator;
};


#define DECLARE_REFLECT_CLASS(NAME,CLASSNAME)/
    static reflectBase *CreateInstance()/
    {/
        return new NAME;/
    }/
    static classdef *class_def##NAME;/
    classdef *GetClassDef()/
    {/
        return class_def##NAME;/
    }/
    struct regClass##NAME/
    {/
        regClass##NAME(){/
        NAME::class_def##NAME = new classdef(CLASSNAME,static_cast<classdef::creator>(&NAME::CreateInstance));/
        }/
    };/
    static regClass##NAME _regClass##NAME;

#define IMPLEMENT_REFLECT_CLASS(NAME)/
    classdef *NAME::class_def##NAME;/
    NAME::regClass##NAME _regClass##NAME;


#define REGISTER_MEMBER(CLASS,NAME,TYPE,MEMBERNAME)/
    Value Get##NAME()/
    {/
        return Value(NAME);/
    }/
    void Set##NAME(const Value &value)/
    {/
        NAME = any_cast<TYPE>(value.GetValue());/
    }/
    struct reg##NAME{/
        reg##NAME()/
        {/
            attribute_op op;/
            op._get = static_cast<attribute_op::func_get>(&CLASS::Get##NAME);/
            op._set = static_cast<attribute_op::func_set>(&CLASS::Set##NAME);/
            Attribute *attr = new Attribute(MEMBERNAME,op);/
            CLASS::class_def##CLASS->AddAttribute(MEMBERNAME,attr);/
        }/
    };/
    static reg##NAME  _reg##NAME;

#define IMPLEMENT_MEMBER(CLASSNAME,NAME)/
    CLASSNAME::reg##NAME CLASSNAME::_reg##NAME;


#define REGISTER_MEMBERFUNCTION_0(CLASS,NAME,RET,FUNCNAME)/
    template<typename Ret>/
    class doCall##NAME/
    {/
    public:/
        static Value doCall(CLASS *obj,const param &_param)/
        {/
            typedef LOKI_TYPELIST_1(void) voidType;/
            return call(obj,_param,Int2Type<IndexOf<voidType,Ret>::value == 0>());/
        }/
    private:/
        static Value call(CLASS *obj,const param &_param,Int2Type<true>)/
        {/
            obj->NAME();/
            return Value(any());/
        }/
        static Value call(CLASS *obj,const param &_param,Int2Type<false>)/
        {/
            return Value(obj->NAME());/
        }/
    };/
    Value call_##NAME(const param &_param = param())/
    {/
        return doCall##NAME<RET>::doCall(this,_param);/
    }/
    struct regMemberFunc0##NAME/
    {/
        regMemberFunc0##NAME()/
        {/
            memberFunc_op op;/
            op._call = static_cast<memberFunc_op::func>(&CLASS::call_##NAME);/
            memberFunction *memfunc = new memberFunction(FUNCNAME,op);/
            CLASS::class_def##CLASS->AddMemberFunc(FUNCNAME,memfunc);/
        }/
    };/
    static regMemberFunc0##NAME _regMemberFunc0##NAME;

#define IMPLEMENT_MEMBERFUNCTION0(CLASSNAME,NAME)/
    CLASSNAME::regMemberFunc0##NAME CLASSNAME::_regMemberFunc0##NAME;

#define REGISTER_MEMBERFUNCTION_1(CLASS,NAME,RET,PARAM1,FUNCNAME)/
    template<typename Ret>/
    class doCall##NAME/
    {/
    public:/
        static Value doCall(CLASS *obj,const param &_param)/
        {/
            typedef LOKI_TYPELIST_1(void) voidType;/
            return call(obj,_param,Int2Type<IndexOf<voidType,Ret>::value == 0>());/
        }/
    private:/
        static Value call(CLASS *obj,const param &_param,Int2Type<true>)/
        {/
            obj->NAME(any_cast<PARAM1>(_param.m_param[0].GetValue()));/
            return Value(any());/
        }/
        static Value call(CLASS *obj,const param &_param,Int2Type<false>)/
        {/
            return Value(obj->NAME(any_cast<PARAM1>(_param.m_param[0].GetValue())));/
        }/
    };/
    Value call_##NAME(const param &_param = param())/
    {/
        return doCall##NAME<RET>::doCall(this,_param);/
    }/
    struct regMemberFunc1##NAME/
    {/
        regMemberFunc1##NAME()/
        {/
            memberFunc_op op;/
            op._call = static_cast<memberFunc_op::func>(&CLASS::call_##NAME);/
            memberFunction *memfunc = new memberFunction(FUNCNAME,op);/
            CLASS::class_def##CLASS->AddMemberFunc(FUNCNAME,memfunc);/
        }/
    };/
    static regMemberFunc1##NAME _regMemberFunc1##NAME;

#define IMPLEMENT_MEMBERFUNCTION1(CLASSNAME,NAME)/
    CLASSNAME::regMemberFunc1##NAME CLASSNAME::_regMemberFunc1##NAME;

#define REGISTER_MEMBERFUNCTION_2(CLASS,NAME,RET,PARAM1,PARAM2,FUNCNAME)/
    template<typename Ret>/
    class doCall##NAME/
    {/
    public:/
        static Value doCall(CLASS *obj,const param &_param)/
        {/
            typedef LOKI_TYPELIST_1(void) voidType;/
            return call(obj,_param,Int2Type<IndexOf<voidType,Ret>::value == 0>());/
        }/
    private:/
        static Value call(CLASS *obj,const param &_param,Int2Type<true>)/
        {/
            obj->NAME(any_cast<PARAM1>(_param.m_param[0].GetValue()),any_cast<PARAM2>(_param.m_param[1].GetValue()));/
            return Value(any());/
        }/
        static Value call(CLASS *obj,const param &_param,Int2Type<false>)/
        {/
            return Value(obj->NAME(any_cast<PARAM1>(_param.m_param[0].GetValue()),any_cast<PARAM2>(_param.m_param[1].GetValue())));/
        }/
    };/
    Value call_##NAME(const param &_param = param())/
    {/
        return doCall##NAME<RET>::doCall(this,_param);/
    }/
    struct regMemberFunc2##NAME/
    {/
        regMemberFunc2##NAME()/
        {/
            memberFunc_op op;/
            op._call = static_cast<memberFunc_op::func>(&CLASS::call_##NAME);/
            memberFunction *memfunc = new memberFunction(FUNCNAME,op);/
            CLASS::class_def##CLASS->AddMemberFunc(FUNCNAME,memfunc);/
        }/
    };/
    static regMemberFunc2##NAME _regMemberFunc2##NAME;

#define IMPLEMENT_MEMBERFUNCTION2(CLASSNAME,NAME)/
    CLASSNAME::regMemberFunc2##NAME CLASSNAME::_regMemberFunc2##NAME;
    
#endif

 

测试代码

// reflectionTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "any.h"
#include "reflect.h"

class test : public reflectBase
{
public:

    test(){}

    void print(int a)
    {
        printf("haha %d/n",a);
    }

    void print_void()
    {
        printf("print_void/n");
    }

    void print2(const std::string &a,const std::string &b)
    {
        printf("%s,%s/n",a.c_str(),b.c_str());
    }

    int add(int other)
    {
        return membera + other;
    }

    DECLARE_REFLECT_CLASS(test,"test")
    REGISTER_MEMBER(test,membera,int,"membera")
    REGISTER_MEMBER(test,memberb,double,"memberb")
    REGISTER_MEMBERFUNCTION_0(test,print_void,void,"print_void")
    REGISTER_MEMBERFUNCTION_1(test,print,void,int,"print")
    REGISTER_MEMBERFUNCTION_2(test,print2,void,std::string,std::string,"print2")
    REGISTER_MEMBERFUNCTION_1(test,add,int,int,"add")

    int membera;
    double memberb;
};

IMPLEMENT_REFLECT_CLASS(test)
IMPLEMENT_MEMBER(test,membera)
IMPLEMENT_MEMBER(test,memberb)
IMPLEMENT_MEMBERFUNCTION1(test,print)
IMPLEMENT_MEMBERFUNCTION0(test,print_void)
IMPLEMENT_MEMBERFUNCTION2(test,print2)
IMPLEMENT_MEMBERFUNCTION1(test,add)


int _tmain(int argc, _TCHAR* argv[])
{
    test t;
    t.membera = 10;
    t.memberb = 12.0;

    reflectBase *rb = &t;

    Attribute *attr = rb->GetClassDef()->FindAttribute("membera");
    attr->SetValue(*rb,any(100));
    printf("%d/n",any_cast<int>(attr->GetValue(*rb).GetValue()));

    memberFunction *memfun = rb->GetClassDef()->GetMemFunc("print");
    memberFunction::methord methord = memfun->GetMethord();

    (rb->*methord)(param(100));
    


    memfun = rb->GetClassDef()->GetMemFunc("print_void");
    
    methord = memfun->GetMethord();

    (rb->*methord)(param());

    memfun = rb->GetClassDef()->GetMemFunc("print2");
    methord = memfun->GetMethord();
    (rb->*methord)(param(std::string("hello"),std::string("kenny")));

    reflectBase *rb1 = rb->GetClassDef()->CreateInstance();

    printf("%s/n",rb1->GetClassDef()->classname.c_str());

    attr = rb1->GetClassDef()->FindAttribute("membera");
    attr->SetValue(*rb1,any(1000));
    printf("%d/n",any_cast<int>(attr->GetValue(*rb1).GetValue()));

    memfun = rb->GetClassDef()->GetMemFunc("add");

    methord = memfun->GetMethord();

    int sum = any_cast<int>((rb->*methord)(param(100)).GetValue());


    test *t1 = (test*)rb1; 

    getchar();

    return 0;
}