如何通过C++模板编写一个通用的结构体打印函数

to_tuple

std::tuple

tuple

print_value

std::string

std::tuple

to_tuple

to_tuple

std::tuple

tuple

#include <iostream>
#include <string>
#include <tuple>        // 用于将结构体成员打包
#include <type_traits>  // 用于SFINAE和类型判断
#include <utility>      // 用于std::index_sequence, std::apply

// --- 辅助函数：检测类型是否含有静态的 to_tuple 方法 ---
// 这是SFINAE（Substitution Failure Is Not An Error）的一种应用，
// 用于在编译时判断一个类型是否符合我们期望的接口。
template <typename T, typename = void>
struct has_to_tuple_v : std::false_type {};

template <typename T>
struct has_to_tuple_v<T, std::void_t<decltype(T::to_tuple(std::declval<const T&>()))>> : std::true_type {};

template <typename T>
constexpr bool has_to_tuple = has_to_tuple_v<T>::value;

// --- 核心打印函数：print_value (前向声明用于递归) ---
// 所有的打印最终都会通过这个函数进行分发。
template <typename T>
void print_value(std::ostream& os, const T& value);

// --- print_value 的各种特化/重载 ---

// 1. 基本类型（int, double, bool等）的默认处理
template <typename T>
void print_value(std::ostream& os, const T& value) {
    os << value;
}

// 2. std::string 的特化，加上引号使其更清晰
void print_value(std::ostream& os, const std::string& value) {
    os << "\"" << value << "\"";
}

// 3. std::tuple 的处理：递归打印每个元素
template <typename Tuple, std::size_t... Is>
void print_tuple_elements_impl(std::ostream& os, const Tuple& t, std::index_sequence<Is...>) {
    bool first_element = true;
    ((os << (first_element ? "" : ", ") << (print_value(os, std::get<Is>(t)), ""), first_element = false), ...);
}

template <typename... Args>
void print_value(std::ostream& os, const std::tuple<Args...>& t) {
    os << "{ ";
    print_tuple_elements_impl(os, t, std::index_sequence_for<Args...>{});
    os << " }";
}

// 4. 结构体的处理：利用 to_tuple 方法获取成员，然后递归打印
// 这里使用 if constexpr 结合 has_to_tuple 来在编译时选择正确的路径。
template <typename T>
std::enable_if_t<has_to_tuple<T>> print_value(std::ostream& os, const T& value) {
    // 输出类型名称，typeid().name() 通常会给出“被混淆（mangled）”的名称，
    // 但对于调试来说已经足够。
    os << typeid(T).name();
    os << "{ ";
    bool first_member = true;
    // std::apply 用于将 tuple 展开为函数的参数列表，非常适合这种场景。
    std::apply([&](const auto&... args) {
        ((os << (first_member ? "" : ", ") << (print_value(os, args), ""), first_member = false), ...);
    }, T::to_tuple(value)); // 调用结构体定义的 to_tuple 方法
    os << " }";
}

// --- 用户调用的入口函数 ---
template <typename T>
void print_struct(std::ostream& os, const T& obj) {
    print_value(os, obj);
}

// --- 示例结构体 ---
struct Point {
    int x;
    int y;
    double z_coord; // 增加一个浮点数成员

    // 关键：提供一个静态的 to_tuple 方法，将成员打包成 std::tuple
    static auto to_tuple(const Point& p) {
        return std::make_tuple(p.x, p.y, p.z_coord);
    }
};

struct Person {
    std::string name;
    int age;
    Point location; // 嵌套结构体

    // 同样提供 to_tuple 方法
    static auto to_tuple(const Person& p) {
        return std::make_tuple(p.name, p.age, p.location);
    }
};

// 另一个示例，不包含 to_tuple，会被当作基本类型处理
struct SimpleData {
    int value;
};

// int 数组，虽然不是struct，但展示了如何处理非to_tuple类型
void print_int_array(std::ostream& os, const int* arr, size_t size) {
    os << "[";