c++的静态反射与动态反射

动态反射,编译时多态可根据指针类型确定函数,见这里:

元<型名 F>用 值转=函数<空(F*f,常 串&名)>;
//每一项转值,成员项,都可转成指针,指与名对应.指针与&构::值对应

元<型名 T>类 段转基{
公:
  虚~段转基()=默认;
  虚 空 符号()(T*p)常=0;
};

元<型名 T,型名 F>
类 段转:公 段转基<T>{
 公:
  段转(常 串&名,F T::*指针,值转<F>f)
      :名(名),针(指针),z(f){}

  空 符号()(T*p)常 盖{中 z(&(p->*针),名);}
  //注册函数,然后实现,在这里
 私:
  串 名;F T::*针;值转<F>z;
 //&构::值=>名=>函数对应,这里,针和p(对象)在函数中相关联.
};

元<类 T>
类 构值转{//构,设定T,
  向量<独针<段转基<T>>>F_;
公:
  元<型名 F>
  空 注册字段(F T::*针,常 串&名,值转<F>z){
    F_.压后(造独<段转<T,F>>(名,针,移动(z)));
  }//注册的,
  空 符号()(T*p)常{对(动&f:F_)(*f)(p);}
  //这里调用,对外的两个函数
};

使用:

#包含"动态反射.h"

构 简单构{
  极 极_;整 整_;
  双精 双精_;串 串_;
};

整 主(){
  动 m=[](极*f,常 串&名){
    输出<<布尔真假<<名<<"[!串000]"<<*f<<行尾;
  };
  动 n=[](整*f,常 串&名){
    输出<<名<<"[!串001]"<<*f<<行尾;
  };
  动 o=[](双精*f,常 串&名){
    输出<<固定<<名<<"[!串002]"<<*f<<行尾;
  };
  动 l=[](串*f,常 串&名){
    输出<<名<<"[!串003]"<<*f<<行尾;
  };

  构值转<简单构>c;
  c.注册字段(&简单构::极_,"极",值转<极>(m));
  c.注册字段(&简单构::整_,"整",值转<整>(n));
  c.注册字段(&简单构::双精_,"双精",值转<双精>(o));
  c.注册字段(&简单构::串_,"串",值转<串>(l));
  //这是使用方法,太麻烦,要人工手写

  简单构 简单{真,2,2.0,"啊啊啊"};c(&简单);//使用
  中 0;

搞懂没?.下面是静态反射.

元<型名 F,型名 T,大小型...I>
内联 常式 空 每一元组(T&&t,F&&f,引序<I...>){
  用 大=整[];//就是对一个元组项调用.
  (空)大{0,((空)f(取<I>(前向<T>(t))),0)...};
}//这是每一元组,f,为对每一元组中项应用的函数,仔细观察

元<型名 F,型名 T>
内联 常式 空 每一元组(T&&t,F&&f){
  每一元组(前向<T>(t),f,造引序<元组大小<退化型<T>>::值>{});
}//可以另外换一种写法

元<型名 T>构 是针段:假型{};
元<型名 C,型名 T>构 是针段<T C::*>:真型{};
元<型名 T>常式 动 是针段值=是针段<T>::值;

元<型名 T>内联 常式 动 G(){中 造元组();}
#定义 定义概(构,...)\
  元<>内联 常式 动 G<构>(){\
    用 _构=构;中 造元组(__变长实参__);\//这里,加额外参数.
  }//这是一般情况,这个是构造,必须要有G<构>
//有哪些字段?
//_构,接力方式,让下个宏获取上个宏

#定义 定构段(f,n) 造元组(&_构::f,n)//用宏,不然,没法.
//字段,每个字段名字,这两个才是关键.造了个字段,与名字

元<型名 T,型名 F>
内联 常式 空 每一字段(T&&值,F&&f){//每一字段的f=>f(1,2)
  常式 动 g=G<退化型<T>>();
  静断(元组大小<推导(g)>::值!=0,"条件不对");
  每一元组(g,[&值,&f](动&&o){//这里o==>为前面的g.o为形参,g为实参
    用 m=退化型<推导(o)>;
    静断(元组大小<m>::值>=2&&是针段值<元组元素型<0,m>>,"条件不满足");
    //过滤,检查是否定义字段,是否包含位置和名称
    //指针字段是成员指针
    f(值.*(取<0>(前向<推导(o)>(o))),
      取<1>(前向<推导(o)>(o)));//这个f带两个参数
  });//这里推导出来了. //第1个是F

使用:

#包含"静反射.h"

构 简单构{
  极 极_;整 整_;双精 双精_;串 串_;
};

定义概(简单构,定构段(极_,"极"),定构段(整_,"整"),定构段(双精_,"双精"),定构段(串_,"串"));

构 仿函数{
  元<型名 F,型名 名>
  空 符号()(F&&f,名&&名){
    输出<<布尔真假<<固定<<名<<"啊啊"<<f<<行尾;
  }
};

元<类...B>构 重载集;
元<类 F,类...B>
构 重载集<F,B...>:F,重载集<B...>::型{
  又 重载集 型;//这里是为什么?,还没搞懂.要实验
  重载集(F t,B...w):F(t),重载集<B...>::型(w...){}
  用 F::符号();
  用 重载集<B...>::型::符号();//这应该是迭代,后面的,然后生成
};
元<类 F>构 重载集<F>:F{又 F 型;用 F::符号();};

元<类...F>
型名 重载集<F...>::型 重载(F...x){
  中 重载集<F...>(x...);//函数调用
}//()
整 主(){
  每一字段(简单构{真,1,1.0,"啊啊"},
   [](动&&f,动&&名){
     输出<<布尔真假<<固定<<名<<"啊啊"<<f<<行尾;
   });

  每一字段(简单构{真,1,1.0,"啊啊"},仿函数{});
  每一字段(简单构{真,1,1.0,"啊啊"},
   重载(
       [](极 f,常 符*名){输出<<"啊啊"<<f<<行尾;},
       [](整 f,常 符*名){输出<<"啊啊"<<f<<行尾;},
       [](双精 f,常 符*名){
         输出<<"啊啊"<<f<<行尾;
       },
       [](常 串&f,常 符*名){
         输出<<"啊啊"<<f.c串()<<行尾;
       }));
  中 0;
}

看懂没有,反正我也没大看懂.

元<型名 T>构 是可选:假型{};
元<型名 T>构 是可选<独针<T>>:真型{};
元<型名 T>常式 极 是可选值=是可选<退化型<T>>::值;
元<型名 T>
常式 极 有概要=元组大小<推导(构概要<T>())>::值;

元<型名 T>
构 依参查序化器<T,如允许型<有概要<T>>>{//奇怪的语法,在我这,通不过.
  元<型名 基型>静 空 到数格(基型&j,常 T&值){
    每一字段(值,[&j](动&&o,动&&名){j[名]=o;});//这里的f为带两个参数的
  }

  元<型名 基型>静 空 从数格(常 基型&j,T&值){
    每一字段(值,[&j](动&&o,动&&名){//两个参数.
      //忽略缺少的可选字段.
      如(是可选值<推导(o)>&&j.找(名)==j.尾())中;
      j.在(名).取到(o);
    });
  }
};

总之,实现类似前面的模板,借f,来解析元组.每一字段->变成每一元组,值得学习
本一个(每一字段,带两个参数,转变成每一元组,带一个参数).
搞懂了吗?,同志们?