C++结构体反射成员遍历访问技术

P粉602998670

发布时间：2025-08-31 10:28:01

1011人浏览过

来源于php中文网

原创

C++结构体反射可通过宏、模板元编程或Clang LibTooling实现，常用于序列化等场景，其中宏方法简单但侵入性强，模板元编程高效但复杂，Clang工具灵活但难度高。

c++结构体反射成员遍历访问技术

C++结构体反射，说白了，就是能在运行时知道结构体的成员信息，并能遍历和访问它们。这在很多场景下都很有用，比如序列化、反序列化、ORM框架等等。C++本身并没有像Java或C#那样内置的反射机制，所以需要一些技巧来实现。

解决方案

实现C++结构体反射，主要有几种方法：

宏 + 静态成员变量： 这是最常见也相对简单的方法。使用宏来定义结构体，在宏里面定义一个静态成员变量，这个变量是一个数组，存储了结构体所有成员的信息（名字、类型、偏移量等）。

立即学习“C++免费学习笔记（深入）”；

#include 
#include 
#include 

#define STRUCT_BEGIN(name) \
struct name { \
public: \
    static std::vector> fields; \
    name() {}

#define FIELD(type, fieldName) \
    type fieldName; \
    static void addField_##fieldName() { \
        fields.emplace_back(std::make_tuple(#fieldName, typeid(type).name(), offsetof(name, fieldName))); \
    }

#define STRUCT_END(name) \
    struct _initializer { \
        _initializer() { \
            name::fields.reserve(0); /*预分配内存，避免扩容导致地址变化*/\
            /* 使用decltype推断类型，避免手动指定类型*/\
            using addField_func_type = decltype(&name::addField_##fieldName); \
            /* 查找所有以addField_开头的函数，并调用*/\
            auto& fields_ref = name::fields; \
            [](T (&arr)[N]) { \
                for (size_t i = 0; i < N; ++i) { \
                    arr[i](); \
                } \
            }(([]() -> std::array { return {}; }())); \
        } \
    }; \
    static _initializer _init; \
}; \
std::vector> name::fields; \
typename name::_initializer name::_init;

STRUCT_BEGIN(Person)
    FIELD(std::string, name)
    FIELD(int, age)
    FIELD(double, salary)
STRUCT_END(Person)

int main() {
    Person person;
    person.name = "Alice";
    person.age = 30;
    person.salary = 50000.0;

    for (const auto& field : Person::fields) {
        std::cout << "Name: " << std::get<0>(field)
                  << ", Type: " << std::get<1>(field)
                  << ", Offset: " << std::get<2>(field) << std::endl;

        // 可以根据偏移量访问成员
        if (std::get<0>(field) == "name") {
            std::string* namePtr = (std::string*)((char*)&person + std::get<2>(field));
            std::cout << "Value: " << *namePtr << std::endl;
        } else if (std::get<0>(field) == "age") {
            int* agePtr = (int*)((char*)&person + std::get<2>(field));
            std::cout << "Value: " << *agePtr << std::endl;
        } else if (std::get<0>(field) == "salary") {
            double* salaryPtr = (double*)((char*)&person + std::get<2>(field));
            std::cout << "Value: " << *salaryPtr << std::endl;
        }
    }

    return 0;
}

优点： 实现简单，易于理解。 缺点： 需要使用宏，侵入性强。类型信息是字符串，不如 typeid 精确。依赖于编译器对offsetof的实现，某些情况下可能不准确。

模板元编程： 使用模板元编程可以在编译期获取结构体成员信息，并生成相应的代码。这种方法不需要宏，但是代码会比较复杂。

#include 
#include 
#include 
#include 

template 
struct FieldInfo {};

template 
struct StructInfo {
    using type = T;
    using fields = std::tuple;
};

// 示例结构体
struct Person {
    std::string name;
    int age;
    double salary;
};

// 为 Person 结构体定义 FieldInfo
template <>
struct FieldInfo : StructInfo {};

template 
constexpr size_t offsetof_field(FieldType StructType::* field) {
    return reinterpret_cast(&((StructType*)0)->*field);
}

int main() {
    using PersonFields = std::tuple;
    PersonFields fields = std::make_tuple(&Person::name, &Person::age, &Person::salary);

    std::cout << "Offset of name: " << offsetof_field(&Person::name) << std::endl;
    std::cout << "Offset of age: " << offsetof_field(&Person::age) << std::endl;
    std::cout << "Offset of salary: " << offsetof_field(&Person::salary) << std::endl;

    return 0;
}

优点： 不需要宏，代码更清晰。 缺点： 代码复杂，学习曲线陡峭。需要在编译期预先知道结构体信息。

基于Clang LibTooling： Clang LibTooling提供了强大的C++代码分析能力。可以编写一个Clang Tool来解析结构体定义，提取成员信息，并生成相应的反射代码。这种方法最灵活，但是也最复杂。

Adobe Flex 简介中文WORD版
Flex是一个基于组件的开发框架，可以生成一个由Flash Player运行的富互联网应用程序。Flex将基于标准的语言和各种可扩展用户界面及数据访问组件结合起来，使得开发人员能够构建具有丰富数据演示、强大客户端逻辑和集成多媒体的应用程序。 Flex是一个建立在Flash平台上的富客户端应用开发工具包，Flex 作为富 Internet 应用（RIA）时代的新技术代表，自从 2007 年 Adobe 公司将其开源以来，Flex 就以前所未有的速度在成长。感兴趣的朋友可以过来看看

下载

优点： 功能强大，可以处理复杂的C++代码。 缺点： 学习成本高，需要熟悉Clang LibTooling。

如何选择合适的方法？

如果只是简单的结构体，且对性能要求不高，可以使用宏 + 静态成员变量的方法。
如果对性能要求较高，且结构体定义在编译期已知，可以使用模板元编程。
如果需要处理复杂的C++代码，或者需要在运行时动态获取结构体信息，可以使用Clang LibTooling。

如何避免反射带来的性能损失？

反射必然带来性能损失，这是无法避免的。但是可以通过一些方法来减少性能损失：

缓存反射结果： 将反射结果缓存起来，避免重复计算。
使用编译期反射： 尽可能使用编译期反射，减少运行时开销。
避免过度使用反射： 只在必要的时候使用反射，避免过度使用。

如何处理继承和多态的情况？

继承和多态会增加反射的复杂度。需要考虑以下几点：

基类成员的反射： 需要递归地反射基类的成员。
虚函数的处理： 虚函数不能直接通过偏移量访问，需要使用虚函数表。
运行时类型识别（RTTI）： 可以使用RTTI来判断对象的实际类型。

如何将反射应用到序列化和反序列化？

序列化和反序列化是反射的典型应用场景。可以使用反射来遍历结构体的成员，并将成员的值写入到文件中或者从文件中读取出来。

#include 
#include 
#include 
#include 
#include 

#define STRUCT_BEGIN(name) \
struct name { \
public: \
    static std::vector> fields; \
    name() {}

#define FIELD(type, fieldName) \
    type fieldName; \
    static void addField_##fieldName() { \
        fields.emplace_back(std::make_tuple(#fieldName, typeid(type).name(), offsetof(name, fieldName))); \
    }

#define STRUCT_END(name) \
    struct _initializer { \
        _initializer() { \
            name::fields.reserve(0); /*预分配内存，避免扩容导致地址变化*/\
            /* 使用decltype推断类型，避免手动指定类型*/\
            using addField_func_type = decltype(&name::addField_##fieldName); \
            /* 查找所有以addField_开头的函数，并调用*/\
            auto& fields_ref = name::fields; \
            [](T (&arr)[N]) { \
                for (size_t i = 0; i < N; ++i) { \
                    arr[i](); \
                } \
            }(([]() -> std::array { return {}; }())); \
        } \
    }; \
    static _initializer _init; \
}; \
std::vector> name::fields; \
typename name::_initializer name::_init;


STRUCT_BEGIN(Person)
    FIELD(std::string, name)
    FIELD(int, age)
    FIELD(double, salary)
STRUCT_END(Person)

// 序列化函数
template 
void serialize(const T& obj, const std::string& filename) {
    std::ofstream ofs(filename);
    if (!ofs.is_open()) {
        std::cerr << "Failed to open file for writing." << std::endl;
        return;
    }

    for (const auto& field : T::fields) {
        const std::string& fieldName = std::get<0>(field);
        const size_t offset = std::get<2>(field);

        if (fieldName == "name") {
            const std::string* valuePtr = reinterpret_cast(reinterpret_cast(&obj) + offset);
            ofs << fieldName << ":" << *valuePtr << std::endl;
        } else if (fieldName == "age") {
            const int* valuePtr = reinterpret_cast(reinterpret_cast(&obj) + offset);
            ofs << fieldName << ":" << *valuePtr << std::endl;
        } else if (fieldName == "salary") {
            const double* valuePtr = reinterpret_cast(reinterpret_cast(&obj) + offset);
            ofs << fieldName << ":" << *valuePtr << std::endl;
        }
    }

    ofs.close();
}

// 反序列化函数
template 
void deserialize(T& obj, const std::string& filename) {
    std::ifstream ifs(filename);
    if (!ifs.is_open()) {
        std::cerr << "Failed to open file for reading." << std::endl;
        return;
    }

    std::string line;
    while (std::getline(ifs, line)) {
        std::stringstream ss(line);
        std::string fieldName;
        std::string value;

        std::getline(ss, fieldName, ':');
        std::getline(ss, value);

        for (const auto& field : T::fields) {
            if (std::get<0>(field) == fieldName) {
                const size_t offset = std::get<2>(field);

                if (fieldName == "name") {
                    std::string* valuePtr = reinterpret_cast(reinterpret_cast(&obj) + offset);
                    *valuePtr = value;
                } else if (fieldName == "age") {
                    int* valuePtr = reinterpret_cast(reinterpret_cast(&obj) + offset);
                    *valuePtr = std::stoi(value);
                } else if (fieldName == "salary") {
                    double* valuePtr = reinterpret_cast(reinterpret_cast(&obj) + offset);
                    *valuePtr = std::stod(value);
                }
                break;
            }
        }
    }

    ifs.close();
}

int main() {
    Person person;
    person.name = "Alice";
    person.age = 30;
    person.salary = 50000.0;

    serialize(person, "person.txt");

    Person loadedPerson;
    deserialize(loadedPerson, "person.txt");

    std::cout << "Loaded Person: " << loadedPerson.name << ", " << loadedPerson.age << ", " << loadedPerson.salary << std::endl;

    return 0;
}