C++ Runtime Reflection (RTTR)：运行时反射库的应用

好的，各位观众，欢迎来到今天的C++ Runtime Reflection (RTTR) 专场！今天咱们不搞虚的，直接上干货，用RTTR让你的C++代码也能像Java、C#那样玩转反射。

开场白：反射是什么鬼？

想象一下，你是一位侦探，手里只有一堆代码的二进制文件。你需要知道里面都有哪些类，这些类都有哪些方法，方法需要哪些参数，参数类型是什么…… 这就是反射干的事情：在程序运行时，让你能够检查、访问甚至修改程序自身的结构和行为。

在静态语言如C++中，反射能力天然不足。编译时类型信息在运行时会被丢弃，就像灰姑娘午夜十二点被打回原形一样。但别担心，RTTR就像水晶鞋，能让C++也能拥有反射的魔力。

RTTR：你的反射好帮手

RTTR（Runtime Type Reflection）是一个轻量级的C++反射库，它提供了类型信息、属性、方法、构造函数等运行时访问能力。简单来说，RTTR就是为C++插上翅膀，让它也能飞起来！

RTTR的优势：

简单易用： API设计简洁明了，上手容易。
轻量级： 不会给你的程序带来沉重的负担。
跨平台： 支持主流的操作系统和编译器。
功能强大： 覆盖了反射的各个方面，包括类型信息、属性、方法调用等。

准备工作：安装RTTR

要使用RTTR，首先需要将其包含到你的项目中。通常你可以选择以下几种方式：

包管理器: 如果你使用包管理器（例如Conan, Vcpkg），可以直接搜索并安装 RTTR。

# Conan
conan install rttr/latest@ -s compiler.cppstd=17 #根据需要修改cppstd版本

# Vcpkg
vcpkg install rttr

手动编译安装: 从 RTTR 的 GitHub 仓库下载源代码，然后按照其文档进行编译和安装。
直接包含源文件: 这是最简单的方式，直接将 RTTR 的头文件和源文件包含到你的项目中。但这可能会增加编译时间。

安装完成后，确保你的编译器能够找到 RTTR 的头文件。

第一步：注册你的类

在使用RTTR之前，你需要告诉RTTR你的类的信息。这通过宏来完成，被称为注册。

#include <rttr/registration>
#include <iostream>

class MyClass {
public:
    MyClass() : value(0) {}
    MyClass(int val) : value(val) {}

    int getValue() const { return value; }
    void setValue(int val) { value = val = val + 10; } // 做了点小动作

    int add(int a, int b) { return a + b; }

    int value;
private:
    void privateMethod() {}
};

RTTR_REGISTRATION
{
    using namespace rttr;
    registration::class_<MyClass>("MyClass")
        .constructor<>()
        .constructor<int>()
        .property("value", &MyClass::value)
        .method("getValue", &MyClass::getValue)
        .method("setValue", &MyClass::setValue)
        .method("add", &MyClass::add);
}

int main() {
    rttr::type t = rttr::type::get_by_name("MyClass");
    if (t.is_valid()) {
        std::cout << "Class name: " << t.get_name() << std::endl;
    } else {
        std::cout << "Class 'MyClass' not found." << std::endl;
    }
    return 0;
}

这段代码做了什么：

#include <rttr/registration>：包含 RTTR 的注册头文件。
RTTR_REGISTRATION：这是注册宏，所有注册代码都必须放在这个宏内部。
registration::class_<MyClass>("MyClass")：注册名为 "MyClass" 的类。
.constructor<>()：注册默认构造函数。
.constructor<int>(): 注册接受一个 int 参数的构造函数。
.property("value", &MyClass::value)：注册名为 "value" 的属性，并将其关联到 MyClass::value 成员变量。
.method("getValue", &MyClass::getValue)：注册名为 "getValue" 的方法，并将其关联到 MyClass::getValue 成员函数。
.method("setValue", &MyClass::setValue)：注册名为 "setValue" 的方法，并将其关联到 MyClass::setValue 成员函数。
.method("add", &MyClass::add)：注册名为 "add" 的方法，并将其关联到 MyClass::add 成员函数。

重要提示：

注册代码通常放在源文件中，而不是头文件中。
注册宏必须在全局命名空间中。
你可以注册多个类，只需要在 RTTR_REGISTRATION 块中添加多个 registration::class_<> 即可。

第二步：获取类型信息

注册完成后，你就可以使用RTTR来获取类的类型信息了。

#include <rttr/type>
#include <iostream>

int main() {
    rttr::type t = rttr::type::get<MyClass>(); // 通过类型获取
    // rttr::type t = rttr::type::get_by_name("MyClass"); // 通过名称获取

    if (t.is_valid()) {
        std::cout << "Class name: " << t.get_name() << std::endl;
        std::cout << "Is class: " << t.is_class() << std::endl;
        std::cout << "Is constructible: " << t.is_constructible() << std::endl;
    } else {
        std::cout << "Class 'MyClass' not found." << std::endl;
    }

    return 0;
}

这段代码演示了如何通过类型或名称获取类型信息，并检查类型是否有效、是否是类、是否可构造。

第三步：创建对象

RTTR 允许你通过反射来创建对象。

#include <rttr/constructor>

int main() {
    rttr::type t = rttr::type::get<MyClass>();
    rttr::constructor default_constructor = t.get_constructor(); // 获取默认构造函数
    rttr::constructor int_constructor = t.get_constructor({rttr::type::get<int>()}); //获取 int 构造函数

    if (default_constructor.is_valid()) {
        rttr::variant obj = default_constructor.invoke(); // 调用构造函数
        if (obj.is_valid()) {
            MyClass* my_obj = obj.get_value<MyClass*>(); // 获取对象指针（注意内存管理）
            std::cout << "Object created with default constructor." << std::endl;
            delete my_obj; // 记得释放内存
        }
    }

    if (int_constructor.is_valid()) {
        rttr::variant obj = int_constructor.invoke(100); // 调用 int 构造函数
        if (obj.is_valid()) {
            MyClass* my_obj = obj.get_value<MyClass*>(); // 获取对象指针（注意内存管理）
            std::cout << "Object created with int constructor." << std::endl;
            delete my_obj; // 记得释放内存
        }
    }

    return 0;
}

重点：

t.get_constructor()：获取构造函数。你可以不带参数获取默认构造函数，也可以指定参数类型列表来获取特定的构造函数。
constructor.invoke()：调用构造函数创建对象。
variant： RTTR 使用 variant 类型来存储返回值，包括对象指针。
内存管理： 通过反射创建的对象需要手动释放内存。现代C++中，建议使用智能指针来管理，避免内存泄漏。

第四步：访问属性

RTTR 允许你通过反射来访问对象的属性。

#include <rttr/property>

int main() {
    MyClass obj;
    rttr::type t = rttr::type::get<MyClass>();
    rttr::property prop = t.get_property("value");

    if (prop.is_valid()) {
        rttr::variant value = prop.get_value(obj); // 获取属性值
        if (value.is_valid()) {
            std::cout << "Original value: " << value.to_int() << std::endl;
        }

        prop.set_value(obj, 123); // 设置属性值

        value = prop.get_value(obj); // 再次获取属性值
        if (value.is_valid()) {
            std::cout << "New value: " << value.to_int() << std::endl;
        }
    }

    return 0;
}

注意：

t.get_property("value")：获取名为 "value" 的属性。
property.get_value(obj)：获取 obj 对象的 "value" 属性的值。
property.set_value(obj, 123)：设置 obj 对象的 "value" 属性的值为 123。
variant.to_int(): 将variant 转换为 int类型。

第五步：调用方法

RTTR 允许你通过反射来调用对象的方法。

#include <rttr/method>

int main() {
    MyClass obj;
    rttr::type t = rttr::type::get<MyClass>();
    rttr::method getValue_method = t.get_method("getValue");
    rttr::method setValue_method = t.get_method("setValue");
    rttr::method add_method = t.get_method("add");

    if (getValue_method.is_valid()) {
        rttr::variant result = getValue_method.invoke(obj); // 调用 getValue 方法
        if (result.is_valid()) {
            std::cout << "getValue() result: " << result.to_int() << std::endl;
        }
    }

    if (setValue_method.is_valid()) {
        setValue_method.invoke(obj, 42); // 调用 setValue 方法，传入参数 42
        rttr::variant result = getValue_method.invoke(obj); // 再次调用 getValue 方法
        if (result.is_valid()) {
            std::cout << "getValue() result after setValue(42): " << result.to_int() << std::endl;
        }
    }

    if (add_method.is_valid()) {
        rttr::variant result = add_method.invoke(obj, 10, 20); // 调用 add 方法，传入参数 10 和 20
        if (result.is_valid()) {
            std::cout << "add(10, 20) result: " << result.to_int() << std::endl;
        }
    }

    return 0;
}

重点：

t.get_method("methodName")：获取名为 "methodName" 的方法。
method.invoke(obj, args...)：调用 obj 对象的 "methodName" 方法，并传入参数。
variant： RTTR 使用 variant 类型来存储返回值。

高级技巧：元数据（Metadata）

RTTR 允许你为类、属性和方法添加元数据，这些元数据可以在运行时访问。

RTTR_REGISTRATION
{
    using namespace rttr;
    registration::class_<MyClass>("MyClass")
        .property("value", &MyClass::value)
            (
                metadata("description", "The main value of the class"),
                metadata("range", std::make_pair(0, 100))
            )
        .method("add", &MyClass::add)
            (
                metadata("description", "Adds two numbers")
            );
}

int main() {
    rttr::type t = rttr::type::get<MyClass>();
    rttr::property prop = t.get_property("value");

    if (prop.is_valid()) {
        std::cout << "Property name: " << prop.get_name() << std::endl;

        // 获取元数据
        std::string description = prop.get_metadata("description").to_string();
        auto range = prop.get_metadata("range").get_value<std::pair<int, int>>();

        std::cout << "Description: " << description << std::endl;
        std::cout << "Range: [" << range.first << ", " << range.second << "]" << std::endl;
    }

    return 0;
}

元数据应用场景：

UI 生成： 根据元数据自动生成用户界面。
序列化： 根据元数据控制序列化过程。
验证： 根据元数据进行数据验证。
文档生成： 根据元数据生成文档。

一个更完整的例子

#include <iostream>
#include <string>
#include <vector>
#include <rttr/registration>
#include <rttr/type>
#include <rttr/property>
#include <rttr/method>
#include <rttr/constructor>

class Person {
public:
    Person() : age(0) {}
    Person(const std::string& name, int age) : name_(name), age(age) {}

    std::string getName() const { return name_; }
    void setName(const std::string& name) { name_ = name; }

    int getAge() const { return age; }
    void setAge(int age) { this->age = age; }

    std::string greet(const std::string& greeting) const { return greeting + ", " + name_ + "!"; }

    void printHobbies(const std::vector<std::string>& hobbies) const {
        std::cout << "Hobbies: ";
        for (const auto& hobby : hobbies) {
            std::cout << hobby << " ";
        }
        std::cout << std::endl;
    }

private:
    std::string name_;
    int age;
};

RTTR_REGISTRATION
{
    using namespace rttr;
    registration::class_<Person>("Person")
        .constructor<>()
        .constructor<const std::string&, int>()
        .property("name", &Person::getName, &Person::setName)
            (
                metadata("description", "The name of the person.")
            )
        .property("age", &Person::getAge, &Person::setAge)
            (
                metadata("description", "The age of the person.")
            )
        .method("greet", &Person::greet)
            (
                metadata("description", "Greets the person with a custom greeting.")
            )
        .method("printHobbies", &Person::printHobbies)
            (
                metadata("description", "Prints the person's hobbies.")
            );
}

int main() {
    rttr::type person_type = rttr::type::get_by_name("Person");

    // Create an instance of Person using the default constructor
    rttr::variant person_var = person_type.create();
    if (!person_var.is_valid()) {
        std::cerr << "Failed to create Person instance." << std::endl;
        return 1;
    }
    Person* person = person_var.get_value<Person*>();  // 需要注意内存管理

    // Set the name and age using properties
    rttr::property name_prop = person_type.get_property("name");
    rttr::property age_prop = person_type.get_property("age");

    if (name_prop.is_valid() && age_prop.is_valid()) {
        name_prop.set_value(*person, std::string("Alice"));
        age_prop.set_value(*person, 30);
    }

    // Call the greet method
    rttr::method greet_method = person_type.get_method("greet");
    if (greet_method.is_valid()) {
        rttr::variant result = greet_method.invoke(*person, std::string("Hello"));
        if (result.is_valid()) {
            std::cout << "Greeting: " << result.to_string() << std::endl;
        }
    }

    // Call the printHobbies method
    rttr::method print_hobbies_method = person_type.get_method("printHobbies");
    if (print_hobbies_method.is_valid()) {
        std::vector<std::string> hobbies = {"Reading", "Hiking", "Coding"};
        print_hobbies_method.invoke(*person, hobbies);
    }

    // Clean up memory
    delete person;

    return 0;
}

注意事项：

性能： 反射会带来一定的性能开销，因此不建议在性能敏感的场景中过度使用。
编译时错误： RTTR 的注册宏是在编译时处理的，因此一些错误可能在运行时才会暴露出来。
ABI 兼容性： RTTR 的 ABI 兼容性可能不如 C++ 标准库，因此在不同的编译器或平台上使用时需要注意。
内存管理： 通过反射创建的对象需要手动释放内存，建议使用智能指针。

总结：

RTTR是一个强大的C++反射库，它可以让你在运行时检查和操作C++对象的类型信息、属性和方法。虽然反射会带来一定的性能开销，但在某些场景下，它可以大大提高代码的灵活性和可扩展性。

什么时候应该使用反射？

插件系统： 动态加载和使用插件。
对象序列化： 将对象序列化到不同的格式。
UI 框架： 动态创建和配置 UI 元素。
测试框架： 自动生成测试用例。
配置系统： 从配置文件中读取和设置对象属性。

表格总结：RTTR 常用功能

功能	描述	示例
类型注册	将 C++ 类的信息注册到 RTTR 系统中。	`RTTR_REGISTRATION { registration::class_<MyClass>("MyClass").constructor<>().property("value", &MyClass::value); }`
获取类型信息	在运行时获取类的类型信息。	`rttr::type t = rttr::type::get<MyClass>();`
创建对象	在运行时创建类的对象。	`rttr::variant obj = t.create();`
访问属性	在运行时访问和修改对象的属性。	`rttr::property prop = t.get_property("value"); prop.set_value(obj, 123);`
调用方法	在运行时调用对象的方法。	`rttr::method method = t.get_method("getValue"); rttr::variant result = method.invoke(obj);`
元数据	为类、属性和方法添加元数据，在运行时访问。	`registration::property("value", &MyClass::value)(metadata("description", "The main value"));`

结束语：

希望今天的分享能帮助大家更好地理解和使用 RTTR。记住，反射是一把双刃剑，用得好可以让你事半功倍，用不好可能会让你陷入debug的深渊。祝大家编码愉快！下次再见!

发表回复 取消回复

发表回复取消回复