如何实现运行时接收未知结构体作为模板参数的泛型函数？

嘿，这个需求在C里其实可以通过编译期模板元编程来实现——毕竟C本身没有原生的运行时反射，不过结合你提到的“硬编码成员函数获取成员数”这个条件，我们可以搭建一个简洁的解决方案。

核心思路是：让你的“未知结构体”提供两个关键接口（要么结构体本身自带，要么通过外部模板特化补充）：一个返回成员总数的静态函数，以及一个能按索引获取成员的方法。然后用泛型模板遍历所有成员，自动推导每个成员的类型和值。

1. 先定义一个符合接口的“未知结构体”示例 #

假设你的结构体虽然成员信息未知，但能提供必要的元信息接口：

#include <iostream>
#include <typeinfo>
#include <string>

// 示例：完全未知的结构体，只暴露元信息接口
struct MysteryStruct {
private:
    int id;
    std::string username;
    double rating;

public:
    // 你提到的硬编码成员数获取函数
    static constexpr size_t get_member_count() {
        return 3;
    }

    // 按索引获取成员的模板函数（编译期分支）
    template <size_t N>
    auto get_member() const {
        if constexpr (N == 0) return id;
        else if constexpr (N == 1) return username;
        else if constexpr (N == 2) return rating;
    }
};

2. 编写泛型模板函数：遍历并推导所有成员 #

这里提供两种实现方式，分别适配不同的C++标准：

方式1：C++17+ 折叠表达式（更简洁） #

利用C++17的折叠表达式，可以避免递归，代码更清爽：

#include <utility> // 用于std::index_sequence

// 单个成员的处理逻辑：打印类型和值
template <typename T, size_t N>
void process_single_member(const T& obj) {
    auto member_val = obj.template get_member<N>();
    std::cout << "第" << N << "个成员："
              << "类型：" << typeid(member_val).name()
              << "，值：" << member_val << "\n";
}

// 内部辅助函数：展开索引序列
template <typename T, size_t... Is>
void process_all_members_impl(const T& obj, std::index_sequence<Is...>) {
    // 折叠表达式：逐个调用process_single_member
    (process_single_member<T, Is>(obj), ...);
}

// 对外暴露的泛型函数
template <typename T>
void analyze_struct(const T& obj) {
    constexpr size_t member_num = T::get_member_count();
    process_all_members_impl(obj, std::make_index_sequence<member_num>());
}

方式2：模板递归（兼容C++11/14） #

如果需要支持更早的C++标准，递归模板是更稳妥的选择：

#include <type_traits> // 用于std::enable_if

// 递归终止条件：当索引等于成员数时停止
template <typename T, size_t N>
typename std::enable_if<N >= T::get_member_count()>::type
process_all_members_recursive(const T&) {}

// 递归处理每个成员
template <typename T, size_t N = 0>
typename std::enable_if<N < T::get_member_count()>::type
process_all_members_recursive(const T& obj) {
    auto member_val = obj.template get_member<N>();
    std::cout << "第" << N << "个成员："
              << "类型：" << typeid(member_val).name()
              << "，值：" << member_val << "\n";
    // 递归处理下一个成员
    process_all_members_recursive<T, N+1>(obj);
}

// 对外接口
template <typename T>
void analyze_struct(const T& obj) {
    process_all_members_recursive<T>(obj);
}

3. 测试一下效果 #

int main() {
    MysteryStruct my_obj{1001, "code_monkey", 4.8};
    analyze_struct(my_obj);
    return 0;
}

运行后会输出类似这样的结果（typeid的输出格式可能因编译器而异）：

第0个成员：类型：int，值：1001
第1个成员：类型：std::basic_string<char, std::char_traits<char>, std::allocator<char> >，值：code_monkey
第2个成员：类型：double，值：4.8

额外说明：如果没法修改结构体怎么办？ #

如果你的结构体不能直接添加get_member_count()和get_member<N>()，可以通过外部模板特化来补充这些逻辑，比如：

// 假设结构体是第三方的，无法修改
struct ThirdPartyStruct {
    float x;
    bool is_valid;
};

// 外部特化：提供成员数
template <>
struct MemberCount<ThirdPartyStruct> {
    static constexpr size_t value = 2;
};

// 外部特化：提供成员访问
template <size_t N>
auto get_member(const ThirdPartyStruct& obj) {
    if constexpr (N == 0) return obj.x;
    else if constexpr (N == 1) return obj.is_valid;
}

// 然后修改泛型函数，用外部的MemberCount替代结构体自身的get_member_count()

这样就能在不修改原结构体的前提下，实现同样的遍历和类型推导逻辑。

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