C++编译期循环获取变量类型_c++获取结构体所有变量

1.定义类型

首先把所有可能的类型用std::tuple列出：
using Types = std::tuple<float, int, double, std::string, char>;
template<std::size_t N>
using AttributeType = typename std::tuple_element<N, Types>::type;
这里，通过AttributeType<0>就可以得到float 类型 
2.定义属性集
 
将所有的属性和其类型的对应关系列出，由于需要是编译期获得，必须类似加入constexpr 关键字： 
constexpr const char* FLOAT_TYPE = "float";
constexpr const char* INT_TYPE = "int";
constexpr const char* DOUBLE_TYPE = "double";
constexpr const char* STRING_TYPE = "std::string";
constexpr const char* CHAR_TYPE = "char";
constexpr std::array<std::pair<const char*, const char*>, 6> attribute2type = {{
    {"gender", CHAR_TYPE},
    {"age", INT_TYPE},
    {"height", FLOAT_TYPE},
    {"IQ", INT_TYPE},
    {"name", STRING_TYPE},
    {"weight", DOUBLE_TYPE},
}};
3. 获取类型索引
 
根据2中定义的类型字符串，获取1中需要的类型索引N： 
constexpr std::size_t getTypeIndex(const char* name)
    return strings_equal(name, "float") ? 0:
        strings_equal(name, "int") ? 1:
        strings_equal(name, "double") ? 2:
        strings_equal(name, "std::string") ? 3:
        strings_equal(name, "char") ? 4:
        5; // compilation error
这里，需要一个编译期进行字符串比较的函数： 
constexpr bool strings_equal(const char* a, const char* b) {
    return *a == *b && (*a == '\0' || strings_equal(a + 1, b + 1));
4. 编译期循环
 
如何实现编译期的类似for循环呢，显然不能直接用for，模板的特性决定了可以使用编译期递归来进行替代for循环： 
template <typename T>
void print(const char* attribute) {
    std::cout << "attribute = " << attribute << ",type=" <<  typeid(T).name() << std::endl;
constexpr size_t LAST_INDEX = attribute2type.size() - 1;
template <size_t T=LAST_INDEX>
struct PrintHelper {
    public:
        PrintHelper() {
            doPrint<T>();
    private:
        template <size_t N>
        void doPrint() {
            print<AttributeType<getTypeIndex(std::get<N>(attribute2type).second)>>(std::get<N>(attribute2type).first);
            doPrint<N-1>();
template <>
template <>
void PrintHelper<LAST_INDEX>::doPrint<0>() {
    print<AttributeType<getTypeIndex(std::get<0>(attribute2type).second)>>(std::get<0>(attribute2type).first);
将上面所有的代码放到一块，就得到了一个可以在编译期循环获取变量类型的程序： 
#include <string>
#include <iostream>
#include <typeinfo>
#include <tuple>
#include <array>
using Types = std::tuple<float, int, double, std::string, char>;
template<std::size_t N>
using AttributeType = typename std::tuple_element<N, Types>::type;
constexpr bool strings_equal(const char* a, const char* b) {
    return *a == *b && (*a == '\0' || strings_equal(a + 1, b + 1));
constexpr std::size_t getTypeIndex(const char* name)
    return strings_equal(name, "float") ? 0:
        strings_equal(name, "int") ? 1:
        strings_equal(name, "double") ? 2:
        strings_equal(name, "std::string") ? 3:
        strings_equal(name, "char") ? 4:
        5; // compilation error
constexpr const char* FLOAT_TYPE = "float";
constexpr const char* INT_TYPE = "int";
constexpr const char* DOUBLE_TYPE = "double";
constexpr const char* STRING_TYPE = "std::string";
constexpr const char* CHAR_TYPE = "char";
constexpr std::array<std::pair<const char*, const char*>, 6> attribute2type = {{
    {"gender", CHAR_TYPE},
    {"age", INT_TYPE},
    {"height", FLOAT_TYPE},
    {"IQ", INT_TYPE},
    {"name", STRING_TYPE},
    {"weight", DOUBLE_TYPE},
}};
template <typename T>
void print(const char* attribute) {
    std::cout << "attribute = " << attribute << ",type=" <<  typeid(T).name() << std::endl;
constexpr size_t LAST_INDEX = attribute2type.size() - 1;
template <size_t T=LAST_INDEX>
struct PrintHelper {
    public:
        PrintHelper() {
            doPrint<T>();
    private:
        template <size_t N>
        void doPrint() {
            print<AttributeType<getTypeIndex(std::get<N>(attribute2type).second)>>(std::get<N>(attribute2type).first);
            doPrint<N-1>();
template <>
template <>
void PrintHelper<LAST_INDEX>::doPrint<0>() {
    print<AttributeType<getTypeIndex(std::get<0>(attribute2type).second)>>(std::get<0>(attribute2type).first);
int main() {
    PrintHelper<LAST_INDEX>();
    return 0;
上面程序输出： 
$ ./attributeWithType 
attribute = weight,type=d
attribute = name,type=NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
attribute = IQ,type=i
attribute = height,type=f
attribute = age,type=i
attribute = gender,type=c
本文通过下面几个技术点实现了编译期循环获取变量类型： 
通过std::tuple定义变量类型集合，通过typename std::tuple_element<N, Types>::type获取某个变量类型
通过编译期递归实现编译期字符串比较
通过std::get(attribute2type)获取属性
编译期递归实现循环获取变量类型 
Reference
 
https://stackoverflow.com/questions/27490858/how-can-you-compare-two-character-strings-statically-at-compile-time
https://stackoverflow.com/questions/55183295/c-mapping-a-set-of-values-to-types
https://stackoverflow.com/questions/6872919/compile-time-loops
                                    定义了一个模板函数type_name()，可以对传入的模板类型T进行类型判断，结合指针、左值/右值引用、常类型，准确得出变量的类型。在调用该函数时使用了`decltype`关键字，传入待确定的变量，然后输出变量类型。
                                    基于 C++ 14 原生语法，不到 100 行代码：让编译器帮你写 JSON 序列化/反序列化代码，告别体力劳动。
本文不讨论完整的 C++ 反射技术，只讨论结构体 (struct) 的字段 (field) 反射，及其在序列化/反序列化代码生成上的应用。
正文开始于 [sec|静态反射] 部分，其他部分都是铺垫。。可以略读。。。
背景（TL;DR）
很多人喜欢把程序员称为 码农，程序员也经常嘲讽自己每天都在 搬砖。这时候，大家会想：能否构造出一些 更好的工具，代替我们做那些无意义的 体力劳动 呢？
                                    对于C++工程量级比较庞大的代码，代码中的变量、类、函数、结构体的识别都是一件让人头疼的事情，一方面代码越写越多，内容越来越丰富，但是没有办法对已有的代码框架进行高度的整合提炼；另一方面对新人逐渐不友好，增加了学习成本。那么如何获取一些类别信息并进行统筹管理呢？
采用如下宏定义即可，这个宏定义将表达式x直接转换为对应的字符串： 
#define varName(x) #x
#define printExp(exp) cout<<#exp<<"为:\t\t"<<(exp)<<endl
#define printExpToString(