如何优雅地实现 C++ 编译期静态反射

(给CPP开发者加星标，提升C/C++技能)

来源：Netcan

部门请来了软件专家袁英杰咨询师指导我们软件开发，从中我也学到了很多姿势，在此记录下来宝贵的经验。苹果的 mbp 品控真是差劲，写这个东西把 LShift 键 按坏了，真是难受。

反射能做什么

最近和大师聊软件设计，其中一个点是关于反射，反射最大的作用就是序列化、解序列化一个结构体，然后就能够在各个模块之间进行通信交互，不管是跨进程也好，还是跨机器也好，都缺不了反射这个功能，这也是 OO 世界对象交互的载体。

不然就需要人工手写一堆序列化、反序列代码，不仅代码难看，而且工作量大，容易出错。印象最深的一个例子是，大师在一个电信项目，模块之间通过 TLV 格式的消息进行通信，而这些 TLV 格式也是内部实现的，还不是标准的，然后大师定义了一套机制，只需要统一声明一次元数据的信息，然后通过 include 不同头文件，就能对同一个元数据进行不同的解释，比如序列化、解序列到数据库，序列化、解序列到网络，这也是预编译多态技术，仅用 C++98 的特性就能做到。

举一个直观一点的例子，比如打印一个结构体内容（其实就是把结构体转换成字符串）：

struct Point {
    double x;
    double y;
};
Point p { 1, 2 };

那么你可能会这样写：

printf("Point x = %d y = %d", p.x, p.y);

如果有成千上百个结构体，对应的打印函数（序列化到字符串）也就成千上百个，如果利用反射手段，只需要写一次，就能给所有反射对象自动生成打印函数（转换）代码。

引子

后来我在 C++ 社区看到一个讨论，说 C++20 在元编程方面提供了很多便利，其中最大的遍历就是 if-constexpr，再也不用模式匹配写一堆enable_if 了，然后题主给了一个例子，用 C++20 的模板元求结构体的字段数量，代码如下：

struct AnyType {
    template <typename T>
    operator T();
};

template <typename T>
consteval size_t CountMember(auto&&... Args) {
    if constexpr (! requires { T{ Args... }; }) { // (1)
        return sizeof...(Args) - 1;
    } else {
        return CountMember<T>(Args..., AnyType{}); // (2)
    }
}

int main(int argc, char** argv) {
    struct Test { int a; int b; int c; int d; };
    printf("%zu\n", CountMember<Test>());
}

看到这坨代码，我愣了一会，然后问大师这个求结构体字段数量是怎么做到呢？C++ 目前最大缺陷是缺少静态反射能力（这里指的是语言层面提供的静态反射信息，C++23估计会落地），应该很难做到的，分析了一会，终于看懂了，太巧妙了：

1. AnyType声明了类型转换操作符（《C++ Modern design》书中的术语是稻草人函数），可以转换成任意类型。

2. 分支 (2) 通过不断构造所求类型 T = Test，当无法构造时(1)，也就是输入的参数过多，这时候参数个数 - 1就是字段个数。

那么只能 C++20 才能做到么？这里主要用到了 C++17 的if-constexpr特性，C++11可以通过 enable-if 做到，而最主要的是那个 requires，C++20 才支持 concept，C++17 都无法做到。

然后我思考了一下，类型构造，《C++ Modern design》这本书讲过，用 sizeof 做类型推导，给的一个例子是判断一个类是否是另一个类的基类，仅通过 C++98 实现。

C++11 编译期有有两大神器：sizeof + decltype，然后用这两者就能实现同样的功能，这里我用 decltype 来解决上述的 concept 问题：

template <typename T, typename = void, typename ...Ts>
struct CountMember {
    constexpr static size_t value = sizeof...(Ts) - 1;
};

template <typename T, typename ...Ts>
struct CountMember<T, std::void_t<decltype(T{Ts{}...})>, Ts...> {
    constexpr static size_t value = CountMember<T, void, Ts..., AnyType>::value;
};

int main(int argc, char** argv) {
    struct Test { int a; int b; int c; int d; };
    printf("%zu\n", CountMember<Test>::value);
}

同样两种情况，用 decltype(T{Ts{}...}) 来判断是否能够构造对象 T。

如何求宏的可变参数个数？

其实这个问题价值不大，而且强依赖平凡构造函数，最大价值在后面的讨论，大师给我出了一道题，如何求宏的可变参数个数？虽然一时半会写不出来，但是之前还是看过一些框架代码的，最终实现方式如下：

#define GET_NTH_ARG(                                                                        \
    _1,  _2,  _3,  _4,  _5,  _6,  _7,  _8,  _9,  _10, _11, _12, _13, _14, _15, _16,         \
    _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32,         \
    _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48,         \
    _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, n, ...) n

#define GET_ARG_COUNT(...) GET_NTH_ARG(__VA_ARGS__,                     \
        64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, \
        48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, \
        32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, \
        16, 15, 14, 13, 12, 11, 10, 9,  8,  7,  6,  5,  4,  3,  2,  1)

GET_ARG_COUNT(a, b, c)展开后，会调用GET_NTH_ARG，然后得到GET_NTH_ARG(a, b, c, 64, 63, ..., 3, 2, 1) 3，从而得到最终长度 3，进一步延伸，这个宏有什么作用呢？那就是对结构体进行反射，用宏提供结构体的元数据信息，从而生成一些类型信息代码。

结合之前看到的那个框架，与大师进一步交流，发现新世界，解决多年来 cpp 静态反射问题，一下子让很多事变成了可能。（后来找到这个实现方法的最早出处：http://pfultz2.com/blog/2012/07/31/reflection-in-under-100-lines/）

来看看大师 actor 框架中的反射例子：

CAF_begin_message_def(Point)
    CAF_msg_field(x, double)
    CAF_msg_field(y, double)
CAF_end_message_def()

CAF_begin_message_def(Rect)
    CAF_msg_field(p1, Point)
    CAF_msg_field(p2, Point)
    CAF_msg_field(color, uint32_t)
CAF_end_message_def()

现在可以做到这样：

DEFINE_STRUCT(Point,
    (double) x,
    (double) y)

DEFINE_STRUCT(Rect,
    (Point) p1,
    (Point) p2,
    (uint32_t) color)

Rect rect {
    {1.2, 3.4},
    {5.6, 7.8},
    12345678,
};
dumpObj(rect);
/* output:
{
    p1: {
        x: 1.2,
        y: 3.4,
    },
    p2: {
        x: 5.6,
        y: 7.8,
    },
    color: 12345678,
}
*/

后者和通常结构体定义方式非常接近，不需要再写 begin/end 原语了。完整的代码请见：

https://github.com/netcan/recipes/blob/master/cpp/metaproggramming/reflection/StaticRefl.hpp

https://github.com/netcan/recipes/blob/master/cpp/metaproggramming/reflection/StaticRefl.cpp

接下来我们一步步看看是如何实现这个的。

实现一套优雅的反射系统

首先来看看 Point 这个用宏声明生成展开的代码，如下：

struct Point {
    template<typename, size_t>
    struct FIELD;
    static constexpr size_t _field_count_ = 2;
    double x;
    template<typename T>
    struct FIELD<T, 0> {
        T &obj;
        FIELD(T &obj) : obj(obj) {}
        auto value() -> decltype(auto) { return (obj.x); }
        static constexpr const char *name() { return "x"; }
    };
    double y;
    template<typename T>
    struct FIELD<T, 0 + 1> {
        T &obj;
        FIELD(T &obj) : obj(obj) {}
        auto value() -> decltype(auto) { return (obj.y); }
        static constexpr const char *name() { return "y"; }
    };
};

Point所需要的元数据都保存在 Point::FIELD<T, N> 里，而所拥有的字段数在 Point::_field_count_ 中，反射只需要这两个信息，就能够生成通用的序列化、反序列化代码。

最核心的 DEFINE_STRUCT 宏定义如下：

#define DEFINE_STRUCT(st, ...)                                                \
struct st {                                                                   \
    template <typename, size_t> struct FIELD;                                 \
    static constexpr size_t _field_count_ = GET_ARG_COUNT(__VA_ARGS__);       \
    PASTE(FOR_EACH_, GET_ARG_COUNT(__VA_ARGS__)) (FIELD_EACH, 0, __VA_ARGS__) \
};                                                                            \

_field_count信息就是由之前提到的求宏变参个数获取的：GET_ARG_COUNT。

接下来是 FOR_EACH 宏，作用是执行元宏 FIELD_EACH 一定次数（字段数量），而 FIELD_EACH 接收两个参数：

1. 当前字段id（用于生成FIELD<T, id>）

2. 当前字段声明信息，例如 (double) x（用于定义double x，并实现FIELD<T, id> 内容）

先来看看 FIELD_EACH 的定义：

#define FIELD_EACH(i, arg)                    \
    PAIR(arg);                                \
    template <typename T>                     \
    struct FIELD<T, i> {                      \
        T& obj;                               \
        FIELD(T& obj): obj(obj) {}            \
        auto value() -> decltype(auto) {      \
            return (obj.STRIP(arg));          \
        }                                     \
        static constexpr const char* name() { \
            return STRING(STRIP(arg));        \
        }                                     \
    }                                         \

PAIR(arg)这个宏比较有意思，定义如下：

#define PAIR(x) PARE x // PAIR((double) x) => PARE(double) x => double x
#define PARE(...) __VA_ARGS__

举个例子，PAIR((double) x)会展开成 PARE(double) x，因为PARE(double) 得到的是double，所以最终结果是double x，从而定义字段。

另一个关键点是 return (obj.STRIP(arg))，看看STRIP 实现：

#define STRIP(x) EAT x // STRIP((double) x) => EAT(double) x => x
#define EAT(...)

同样的例子，STRIP((double) x)会展开成 EAT(double) x，而EAT(double) 得到空结果，所以最终结果是 return (obj.x);，这样就能通过value() 函数拿到成员字段的 引用。

而最后一个 STRING(STRIP(arg)) 就比较简单了，通过 STRING 得到对应参数字符串，宏的基本用法了：

#define STRING(x) STR(x)
#define STR(x) #x

PASTE(FOR_EACH_, GET_ARG_COUNT(__VA_ARGS__))这句是为了拼出 FOR_EACH_N，PASTE 实现如下：

#define PASTE(x, y) CONCATE(x, y)
#define CONCATE(x, y) x ## y

比如这个例子最终会展开成 FOR_EACH_2(FIELD_EACH, 0, (double) x, (double) y)，继续看看FOR_EACH_2 定义：

#define FOR_EACH_1(func, i, arg)        func(i, arg);
#define FOR_EACH_2(func, i, arg, ...)   func(i, arg); FOR_EACH_1(func, i + 1, __VA_ARGS__)
...

也很简单，直接看展开结果吧：

FIELD_EACH(0, (double) x);
FIELD_EACH(0 + 1, (double) y);

最后这一切，通过宏展开拼装在一起，从而得到所有元信息代码。

遍历查询反射信息

有了宏的一臂之力，接下来就是模板元编程发挥威力的地方了，首先我们需要定义一个高阶函数forEach，实现Vistor 模式，其接受两个参数：

1. 传递反射的对象T&& obj

2. 一个函数f，对对象各个字段进行访问、操作，签名为void(const char* fieldName, FieldT& value)

template<typename T, typename F, size_t... Is> // (1)
inline constexpr void forEach(T&& obj, F&& f, std::index_sequence<Is...>) {
    using TDECAY = std::decay_t<T>;
    (void(f(typename TDECAY::template FIELD<TDECAY, Is>(obj).name(),
            typename TDECAY::template FIELD<TDECAY, Is>(obj).value())), ...);
}

template<typename T, typename F> // (2)
inline constexpr void forEach(T&& obj, F&& f) {
    forEach(std::forward<T>(obj),
            std::forward<F>(f),
            std::make_index_sequence<std::decay_t<T>::_field_count_>{});
}

先看版本 (1)，通过参数包Is... 展开代码，从而将函数 f apply 到各个参数上，还是以 Point 为例，展开代码如下：

(f(Point::FIELD<0>(obj).name(), Point::FIELD<0>(obj).value()),
f(Point::FIELD<1>(obj).name(), Point::FIELD<1>(obj).value()));

而 std::index_sequence<0, 1> 可以通过 std::make_index_sequence 得到，避免用户指定字段个数，这也是最终版本 (2) 所做的事。

反射系统的应用

最后来看看反射最基本的一个应用，也就是序列化，将结构体序列化成字符串，从而打印出来，我们通过实现 dumpObj 来做到：

template<typename T>
void dumpObj(T&& obj, const char* fieldName = "", int depth = 0) {
    auto indent = [depth] {
        for (int i = 0; i < depth; ++i) {
            std::cout << "";
        }
    };

    if constexpr(std::is_class_v<std::decay_t<T>>) { // (1)
        indent();
        std::cout << fieldName << (*fieldName ? ": {" : "{") << std::endl;
        forEach(obj, [depth](auto&& fieldName, auto&& value) {
            dumpObj(value, fieldName, depth + 1);
        });
        indent();
        std::cout << "}" << (depth == 0 ? "" : ",") << std::endl;
    } else { // (2)
        indent();
        std::cout << fieldName << ":" << obj << "," << std::endl;
    }
}

这是一个递归版本，通过检查是否为基本类型，来判断是否需要递归打印。如果是基本类型，走分支(2)，直接将其打印出来，如果是结构体，走分支(1)，进一步递归遍历结构体各个字段，直到基本类型为止。

结论、展望未来

可惜目前 C++ 语言未能提供反射信息，目前只能手动描述对应的元信息，综上是 C++ 反射的优雅实现，仅需要实现一遍，通过宏展开生成代码，结合模板元编程的威力，就能为任意结构体生成对应的序列化、反序列化代码，减少程序员重复劳动、容易出错的问题。

期待未来 C++23 能提供反射信息，利用其模板元生成局部代码来替代宏，将减少这些 tricky 代码，不过目前该方案已经足够好用。

Rust的宏能力也很强，能够匹配 {, [, (，而 C 的宏只能匹配(，最后定义出来的语句就不够直观了。在 C++ 中需要结合宏与模板元来生成代码，而 Rust 只需要 过程宏 / 属性宏 和声明宏 ，统一的宏机制就能达到类似效果，而且宏内还能做模式匹配。若C++23 的模板能够生成局部代码，那么也能统一用模板机制搞定很多事了。

最后引用大师说的，C++就像一片大海，给程序员足够的自由，挖掘的越多，乐趣也就越多，每个点都能挖掘出来很多玩法，比如宏，比如模板。世界是复杂的，需要一门大而全的语言来应对这一切复杂。

- EOF -

推荐阅读  点击标题可跳转

关于 C++ 编译期静态反射，欢迎在评论中和我探讨。觉得文章不错，请点赞和在看支持我继续分享好文。谢谢！

关注『CPP开发者』

看精选C++技术文章 . 加C++开发者专属圈子

↓↓↓

点赞和在看就是最大的支持❤️