如何在C++17及以下版本通过键值语义查找嵌套结构体成员

方案说明 #

使用Boost.PFR（Plain Old Data Reflection）实现无侵入式的结构体字段访问，完全满足你的约束：无需修改原始结构体，支持C++17及更低版本。Boost.PFR是Boost库中轻量的反射组件，专门用于处理聚合类型（如示例中的结构体）。

实现步骤 #

1. 依赖准备

确保使用Boost 1.70及以上版本，包含必要头文件：

#include <boost/pfr.hpp>
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <cstdint>
#include <stdexcept>

2. 字符串分割工具

实现字符串分割函数，将嵌套字段路径（如"member4.member3"）拆分为单独的字段名：

std::vector<std::string> split(const std::string& s, char delim) {
    std::vector<std::string> parts;
    std::stringstream ss(s);
    std::string part;
    while (std::getline(ss, part, delim)) {
        if (!part.empty()) {
            parts.push_back(part);
        }
    }
    return parts;
}

3. 单字段查找函数

遍历结构体字段，匹配运行时传入的字段名，返回对应字段的引用：

template<typename T>
const auto& find_field(const T& obj, const std::string& field_name) {
    static_assert(boost::pfr::tuple_size<T>::value > 0, "Target type has no accessible fields");
    const void* field_ptr = nullptr;

    // 遍历结构体所有字段，匹配名字
    boost::pfr::for_each_field(obj, [&](const auto& field, std::size_t idx) {
        if (boost::pfr::get_name<idx, T>() == field_name) {
            field_ptr = &field;
        }
    });

    if (!field_ptr) {
        throw std::invalid_argument("Field not found: " + field_name);
    }
    return *static_cast<const std::decay_t<decltype(*field_ptr)>*>(field_ptr);
}

4. 嵌套字段递归访问

通过递归方式逐层访问嵌套结构体的字段：

template<typename T>
const auto& get_nested_field(const T& obj, const std::vector<std::string>& fields, size_t current_idx = 0) {
    if (current_idx >= fields.size()) {
        return obj;
    }
    const auto& current_field = find_field(obj, fields[current_idx]);
    return get_nested_field(current_field, fields, current_idx + 1);
}

5. 重载operator[]实现语法糖

为结构体添加非成员的operator[]，让调用方式符合你的预期：

template<typename T>
const auto& operator[](const T& obj, const std::string& search_str) {
    auto fields = split(search_str, '.');
    return get_nested_field(obj, fields);
}

测试代码 #

使用你提供的示例结构体进行测试：

namespace example {
    struct Object1 {
        int32_t     member1;
        int32_t     member2;
        std::string member3;
    };

    struct Object2 {
        int32_t member1;
        int32_t member2;
        int32_t member3;
        Object1 member4;
    };
}

void do_some_operation(const example::Object2& obj, const std::string& search_str) {
    try {
        const auto& result = obj[search_str];
        // 通用打印处理，适配不同类型字段
        auto print = [](const auto& val) { std::cout << val; };
        print(result);
        std::cout << "\n";
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << "\n";
    }
}

int main() {
    example::Object2 test_obj{100, 200, 300, {1, 2, "hello"}};
    do_some_operation(test_obj, "member1");          // 输出：100
    do_some_operation(test_obj, "member4.member3");  // 输出：hello
    do_some_operation(test_obj, "member4.member1");  // 输出：1
    return 0;
}

注意事项 #

• 聚合类型限制：Boost.PFR仅支持聚合类型（无自定义构造函数、无基类、无虚函数的结构体/类），示例中的结构体完全符合要求。
• 性能优化：当前实现每次查找字段都会遍历所有字段，若结构体字段较多，可预生成字段名到索引的静态映射，使用boost::pfr::get<index>(obj)直接访问，提升性能。
• 错误处理：字段不存在时会抛出std::invalid_argument异常，需在调用处捕获处理。
• Boost版本：必须使用Boost 1.70及以上版本，因为Boost.PFR从该版本开始正式提供。

内容的提问来源于stack exchange，提问作者Saransh