可变参数模板

template <typename... Args>
void print(Args... args);  // Args 是类型参数包，args 是函数参数包

#include <iostream>
#include <string>
#include <sstream>

// ====== C++11 递归展开 ======

// 终止条件：无参数时什么都不做
void format_print(std::ostream& os) {}

// 递归展开：每次处理第一个参数
template <typename T, typename... Args>
void format_print(std::ostream& os, const T& first, const Args&... rest) {
    os << first;
    if constexpr (sizeof...(rest) > 0) {
        os << ", ";
    }
    format_print(os, rest...);
}

// 包装函数
template <typename... Args>
void println(const Args&... args) {
    format_print(std::cout, args...);
    std::cout << std::endl;
}

// ====== 求和函数：递归展开 ======

// 终止条件
template <typename T>
T variadic_sum(T last) {
    return last;
}

template <typename T, typename... Args>
T variadic_sum(T first, Args... rest) {
    return first + variadic_sum(rest...);
}

// ====== 拼接字符串——C++17 折叠表达式 ======

template <typename... Args>
std::string concat(const Args&... args) {
    std::ostringstream oss;
    (oss << ... << args);  // 二元左折叠：(((oss << a1) << a2) << a3)
    return oss.str();
}

// ====== 全真判断 ======

template <typename... Args>
bool all_true(Args... args) {
    return (... && args);  // 一元右折叠：a1 && (a2 && (a3 && true))
}

int main() {
    std::cout << "===== 泛型打印 =====" << std::endl;
    println("Hello", 42, 3.14, std::string("World"));
    println("学生:", "张三", "分数:", 95);

    std::cout << "\n===== 求和 =====" << std::endl;
    std::cout << "sum(1,2,3,4,5) = " << variadic_sum(1, 2, 3, 4, 5) << std::endl;
    std::cout << "sum(1.1, 2.2, 3.3) = " << variadic_sum(1.1, 2.2, 3.3) << std::endl;

    std::cout << "\n===== 折叠表达式 =====" << std::endl;
    std::cout << "concat: " << concat("C++", 17, " is ", "modern") << std::endl;
    std::cout << "all_true(true, true, false, true): "
              << std::boolalpha << all_true(true, true, false, true) << std::endl;
    std::cout << "all_true(true, true, true): "
              << all_true(true, true, true) << std::endl;

    return 0;
}

#include <iostream>
#include <string>
#include <utility>

// ====== 简易 Tuple 实现 ======

// 主模板声明
template <typename... Types>
class Tuple;

// 递归基：空 Tuple
template <>
class Tuple<> {
public:
    static constexpr size_t size = 0;
};

// 递归定义：Tuple<Head, Tail...>
template <typename Head, typename... Tail>
class Tuple<Head, Tail...> : private Tuple<Tail...> {
public:
    Tuple() = default;

    Tuple(Head head, Tail... tail)
        : head_(std::move(head)), Tuple<Tail...>(std::move(tail)...) {}

    Head& head() { return head_; }
    const Head& head() const { return head_; }

    Tuple<Tail...>& tail() {
        return *this;  // 向上转型为基类
    }

    const Tuple<Tail...>& tail() const {
        return *this;
    }

    static constexpr size_t size = 1 + sizeof...(Tail);

private:
    Head head_;
};

// ====== 按索引获取元素 ======

template <size_t Index, typename TupleType>
struct TupleElement;

// 索引 0：取当前 Tuple 的 head
template <typename Head, typename... Tail>
struct TupleElement<0, Tuple<Head, Tail...>> {
    using type = Head;

    static Head& get(Tuple<Head, Tail...>& t) { return t.head(); }
    static const Head& get(const Tuple<Head, Tail...>& t) { return t.head(); }
};

// 索引 N > 0：递归到 tail
template <size_t Index, typename Head, typename... Tail>
struct TupleElement<Index, Tuple<Head, Tail...>> {
    using type = typename TupleElement<Index - 1, Tuple<Tail...>>::type;

    static type& get(Tuple<Head, Tail...>& t) {
        return TupleElement<Index - 1, Tuple<Tail...>>::get(t.tail());
    }

    static const type& get(const Tuple<Head, Tail...>& t) {
        return TupleElement<Index - 1, Tuple<Tail...>>::get(t.tail());
    }
};

// 获取函数
template <size_t Index, typename... Types>
auto get(Tuple<Types...>& t)
    -> typename TupleElement<Index, Tuple<Types...>>::type& {
    return TupleElement<Index, Tuple<Types...>>::get(t);
}

int main() {
    std::cout << "===== 简易 Tuple =====" << std::endl;

    Tuple<int, std::string, double> t(42, "Hello", 3.14);

    std::cout << "Tuple size: " << t.size << std::endl;
    std::cout << "get<0>: " << get<0>(t) << std::endl;
    std::cout << "get<1>: " << get<1>(t) << std::endl;
    std::cout << "get<2>: " << get<2>(t) << std::endl;

    return 0;
}