前两天有人提到C++没反射，写了个实验版

windoze

C++的确没反射，我一开始搞了一个code generator，后来发现这么搞对于build system实在影响太大，所以后来我干脆转去用宏了。
代码在 https://github.com/windoze/cxl
这是一个header only库，大概这么用：
如果你有一个struct SC

1. 
   
2. struct SC {
   
3.     int m1;
   
4.     const double m2;
   
5. 
   
6.     SC(int mm1, double mm2, int mm3) : m1(mm1), m2(mm2), m3(mm3) {}
   
7.     int get_m3() const { return m3; }
   
8.     void set_m3(int x) { m3 = x; }
   
9. 
   
10.     int get_m4() const { return 100; }
    
11. private:
    
12.     int m3;
    
13. };
    

复制代码

在外面定义几个宏：

1. 
   
2. CXL_EXT_BEGIN_REFLECTED(SC, 4)
   
3.         CXL_REFLECTED_MEMBER(0, m1)
   
4.         CXL_REFLECTED_MEMBER(1, m2, CXL_SQL_FIELD("field2"))
   
5.         CXL_REFLECTED_ATTRIBUTE(2, int, m3, CXL_MEM_GETTER(get_m3), CXL_MEM_SETTER(set_m3))
   
6.         CXL_REFLECTED_RO_ATTRIBUTE(3, int, m4, CXL_MEM_GETTER(get_m4))
   
7. CXL_EXT_END_REFLECTED()
   

复制代码

然后这个struct SC就可以支持反射了，比如你可以动态读写field：

1. 
   
2. SC sc(10, 5.5, 84);
   
3. cxl::set(0, sc, 42);
   
4. assert(sc.m1==42);
   
5. assert(cxl::get<int>(0, sc)==42);
   

复制代码

如果，field不能写或不能用你提供的类型读写，则会在运行时抛出std::bad_cast，而不是编译错误，比如：

1. 
   
2. try {
   
3.         cxl::set(1, sc, 7.5);
   
4.         cxl::get<std::string>(0, sc);
   
5.         assert(false);
   
6. } catch(std::bad_cast&) {
   
7. }
   

复制代码

你还可以访问每个字段的一些metadata，目前预定义的有name, key, sql_table, sql_field, json_key, xml_node, xml_namespace, csv_field, 如要扩展可以在cxl/reflection/reflection_impl.hpp里加，三句话就行。
这些metadata可以用来干一些有用的事，比如：

1. 
   
2.     // 玩具SQL生成器
   
3.     std::string keys;
   
4.     for(size_t i=0; i<cxl::tuple_size<SC>::value; i++) {
   
5.         if(!keys.empty()) keys+=", ";
   
6.         keys+=get_element_sql_field<SC>(i);
   
7.     }
   
8.     keys = "SELECT " + keys + " FROM " + cxl::get_sql_table<SC>() + " WHERE "
   
9.            + cxl::get_element_sql_field<SC>(0) + "=?";
   
10.     assert(keys == "SELECT m1, field2, m3, m4 FROM SC WHERE m1=?");
    

复制代码

fender0107401

哈哈，阿猫猛啊。

windoze

回复 2# fender0107401

之前就是你发帖子说这事的吧，我写这个东西就是验证一下思路，，因为我倾向于把尽量多的事放在编译期做完，所以选择了一个把任意结构体往std::tuple上靠拢的方案，运行时的动态性用variant。
你试试看这个方向可行不可行
@yulihua49

fender0107401

回复 3# windoze

是啊，之前就是我希望C++里面能有反射。那个时候想用C++来代替PHP来做网站的后端。

   

cokeboL

楼主雄壮V5，87侧漏！

truekbcl

sf里面有几个cpp的反射库。楼主的宏里面加如数字，以及索引，对于维护比较麻烦，可以不用。对于自定义的成员，写traits解决。我个人看法，函数反射基本没有什么用处。要处理成员，外部提供算法比较好，而且好扩展，好维护。

yulihua49

windoze 发表于 2015-10-25 16:28
回复 2# fender0107401

之前就是你发帖子说这事的吧，我写这个东西就是验证一下思路，，因为我倾向于把 ...

我在做数据库时，写几个通用函数：
select，fetch，insert，update，delete，execute。。。。。。
这些函数在编译时并不知道具体的数据结构。
他们必须解决自动绑定的问题。否则，动辄上百的列都让用户去做，包装的意义少了一大半。

一个例子，如果写一个类似ORACLE的sqlldr的东西，能够加载任意表进数据库，或者反之。
用你这方法，我不知道怎么弄。运行时人家才告诉我表名和对应的数据（编译期解决不了这些问题）。
退一步讲，有时应用程序是知道数据结构的，他把数据提交给上述函数，那些函数是不知道这些数据的结构的。
真反射可以解决上述问题，但是：
一个对象里的内容，有些是要对应到数据库，有些不是，有些临时不是，怎么表示？
一个对象里的内容，内存的类型和格式与数据库的不符，怎么办？
一个对象里的内容，有些是要序列化到JSON或XML，有些不是，有些临时不是，怎么表示？
需要类似JAVAbean的对象，还要加上一些属性来表示。

yulihua49

truekbcl 发表于 2015-10-26 13:14
sf里面有几个cpp的反射库。楼主的宏里面加如数字，以及索引，对于维护比较麻烦，可以不用。对于自定义的成员 ...

把Object序列化成JSON、XML，或反之。
各种，很多的Object，只想写两个函数：序列化和反序列化。处理各种对象。怎么办？
现在的状况，每种Object都要写两个，太不优雅了！

windoze

回复 7# yulihua49

你的理解有误，尽管“类型”可以有任意多个，但这些“类型”并不是凭空生成的，每个类型都是基本类型的排列组合，这一点就算对于数据库也一样。
反射的意义不在于处理任意类型，事实上你也没办法写出直接处理任意类型的程序，但反射能告诉你一个特定的类型是由哪些基本类型排列组合而成的，这样你就可以用一组处理基本类型的代码处理任意类型。
以std::tuple为例，它本身是一个template，可以包含任意多个任意类型的成员，如果我要写一个to_json以支持任意一个tuple，我可以这么做：

1. 
   
2. std::string to_json(int v) {...}
   
3. std::string to_json(double v) {...}
   
4. std::string to_json(const std::string v) { return std::string("\"") + escape(v) + "\""; }   // escape生成转义后的字符串
   
5. ...
   
6. // 以上为处理基本类型的代码
   
7. 
   
8. 
   
9. template<T> std::string to_json(const std::vector<T> &v) {
   
10.     std::string s("[");
    
11.     bool first=true;
    
12.     for(auto &&e: v) {
    
13.         if(first) first=false;
    
14.         else s+=", ";
    
15.         s+=to_json(e);
    
16.     }
    
17.     s+= "]";
    
18.     return s;
    
19. }
    
20. 
    
21. template<K, V> std::string to_json(const std::map<K, V> &v) {
    
22.     std::string s("{");
    
23.     bool first=true;
    
24.     for(auto &&e: v) {
    
25.         if(first) first=false;
    
26.         else s+=", ";
    
27.         s+= to_json(e.first) + ":" + to_json(e.second);
    
28.     }
    
29.     s+= "}";
    
30.     return s;
    
31. }
    
32. //以上为处理STL容器的代码
    
33. 
    
34. 
    
35. // 遍历tuple
    
36. template<size_t I, size_t N> struct tuple_to_json_impl {
    
37.     template<typename T> std::string operator()(const T& t) const {
    
38.         std::string s(to_json(std::get<I>(t)));
    
39.         // Not the last element, add a separator
    
40.         if (I<N-1) s+=", ";
    
41.         s+=tuple_to_json_impl<I+1, N>()(t);
    
42.         return s;
    
43.     }
    
44. };
    
45. // 遍历tuple结束
    
46. template<size_t N> struct tuple_to_json_impl<N, N> {
    
47.     template<typename T> std::string operator()(const T& t) const {}
    
48. };
    
49. typename<typename ...T> std::string to_json(const std::tuple<T...> &t) {
    
50.     std::string s("[");
    
51.     s+= tuple_to_json_impl<std::tuple<T...>>()(t) + "]";
    
52.     return s;
    
53. }
    

复制代码

有了上面这段代码，你就可以用一个叫做"to_json"的函数把基本类型和任意一个tuple类型都变成JSON string，不需要针对每一个不同的tuple都做一遍。
当然，上面这段代码没有运行时的动态性，尽管从代码角度来说它可以处理任意一个tuple，但它所处理的每一个tuple其实都是在编译期确定下来的。

想要在运行时的动态性，可以用boost::variant/cxl::variant(这两个东西功能类似，API也基本一样，我的cxl::variant差不多是一个C++11版的boost::variant，加了些小功能)
现在加入一个variant版的to_json：

1. 
   
2. struct to_json_visitor {
   
3.     template<typename T> std::string operator(const T &t) const {
   
4.         return to_json(t);
   
5.     }
   
6. };
   
7. template<typename ...T> to_json(const cxl::variant<T...> &t) {
   
8.     return t.apply_visitor(to_json_visitor());
   
9. }
   

复制代码

好了，有了以上的东西，我们可以定义一个JSON数据结构：

1. 
   
2. struct JSON_object;
   
3. typedef cxl::variant<std::nullptr_t, int, double, std::string, std::vector<cxl::recursive_wrapper<JSON_object>>, std::map<cxl::recursive_wrapper<JSON_object>>> JSON_value;
   
4. struct JSON_object {
   
5.     template<typename T>
   
6.     JSON_object(const T&t) : value(t) {}
   
7.     JSON_value value;
   
8. };
   
9. //再加两个用于支持null和任意JSON_object的函数
   
10. std::string to_json(std::nullptr_t) { return "null"; }
    
11. std::string to_json(const JSON_object &obj) { return to_json(obj.value); }
    

复制代码

有了上面这些代码，我们可以用JSON_object存放任意结构的JSON对象，比如：

1. 
   
2. JSON_object obj1=10;
   
3. JSON_object obj2=5.6;
   
4. JSON_object obj3=std::vector<JSON_object>{1, "this is a string", std::map<JSON_object, JSON_object>{{"key1", "value1"}, {"key2", 200}}};
   

复制代码

而且还可以用to_json把它们变成JSON string。

yulihua49

windoze 发表于 2015-10-26 17:08
回复 7# yulihua49

你的理解有误，尽管“类型”可以有任意多个，但这些“类型”并不是凭空生成的，每个 ...

怎样知道我的g++是否支持C++11呢？
看的晕晕，好像tuple可以用于存储模板。
那个get<1>,get<2>也晕，不是<type>吗？怎么玩起下标来了？