C++ 笔记：可变参数模板：参数包展开与折叠表达式

// C 风格：va_list（类型不安全）
void func(int count, ...) {
    va_list args;
    va_start(args, count);
    // 类型不安全，容易出错
    va_end(args);
}

// 函数重载：需要为每个参数数量写一个版本
void print() {}
void print(int a) {}
void print(int a, int b) {}
void print(int a, int b, int c) {}
// ... 需要很多重载

// 一个模板函数处理所有情况
template<typename... Args>
void print(Args... args) {
    // 类型安全，编译期确定
}

// 类型参数包
template<typename... Args>
void func(Args... args) {
    // Args 是类型参数包
    // args 是函数参数包
}

// 非类型参数包
template<int... Values>
void func() {
    // Values 是非类型参数包
}

template<typename... Args>
void func(Args... args) {
    constexpr size_t count = sizeof...(Args);  // 参数包大小
    constexpr size_t args_count = sizeof...(args);  // 参数包大小
}

template<typename... Args>
void print(Args... args) {
    // 展开为：print(arg1, arg2, arg3, ...)
    std::cout << args... << "\n";  // 错误：不能直接展开
}

// 终止条件
void print() {
    std::cout << "\n";
}

// 递归展开
template<typename T, typename... Args>
void print(T first, Args... rest) {
    std::cout << first << " ";
    print(rest...);  // 递归展开剩余参数
}

// 使用
print(1, 2.5, "hello", 'c');  // 输出：1 2.5 hello c

template<typename... Args>
void func(Args... args) {
    // 模式展开
    helper(args...);           // 直接展开
    helper((args + 1)...);     // 每个参数加 1
    helper(f(args)...);        // 每个参数应用函数 f
    helper(g(args, 1)...);     // 每个参数调用 g(args, 1)
}

// 左折叠
template<typename... Args>
auto sum_left(Args... args) {
    return (args + ...);  // ((arg1 + arg2) + arg3) + ...
}

// 右折叠
template<typename... Args>
auto sum_right(Args... args) {
    return (... + args);  // arg1 + (arg2 + (arg3 + ...))
}

// 左折叠（需要初始值）
template<typename... Args>
auto sum_with_init(int init, Args... args) {
    return (init + ... + args);  // init + arg1 + arg2 + ...
}

// 右折叠（需要初始值）
template<typename... Args>
auto sum_with_init_right(Args... args, int init) {
    return (args + ... + init);  // arg1 + arg2 + ... + init
}

// 打印所有参数
template<typename... Args>
void print_all(Args... args) {
    ((std::cout << args << " "), ...);  // 逗号折叠
    std::cout << "\n";
}

// 检查所有参数是否满足条件
template<typename... Args>
bool all_positive(Args... args) {
    return ((args > 0) && ...);  // 逻辑与折叠
}

template<typename... Args>
auto make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

template<typename Func, typename... Args>
auto call_with_log(Func&& f, Args&&... args) {
    std::cout << "Calling function with " << sizeof...(args) << " arguments\n";
    return std::invoke(std::forward<Func>(f), std::forward<Args>(args)...);
}

template<typename... Args>
void apply_tuple(std::tuple<Args...>&& t, Func&& f) {
    std::apply(std::forward<Func>(f), std::move(t));
}

// 检查所有类型是否相同
template<typename T, typename... Args>
struct all_same : std::false_type {};

template<typename T>
struct all_same<T> : std::true_type {};

template<typename T, typename U, typename... Args>
struct all_same<T, U, Args...> 
    : std::conditional_t<std::is_same_v<T, U>, 
                         all_same<T, Args...>, 
                         std::false_type> {};

template<typename... Args>
void safe_func(Args... args) {
    static_assert((std::is_integral_v<Args> && ...), 
                  "All arguments must be integral");
    // 函数实现
}

// 编译期展开为具体函数调用
print(1, 2, 3);
// 展开为：
// print_impl(1, print_impl(2, print_impl(3, print_impl())))

// 推荐：折叠表达式
template<typename... Args>
auto sum(Args... args) {
    return (args + ...);
}

// 不推荐：递归展开
template<typename T>
auto sum(T t) { return t; }
template<typename T, typename... Args>
auto sum(T t, Args... args) {
    return t + sum(args...);
}