C++模板递归实例化 可变参数模板处理

std::tuple

#include <iostream>
#include <string>

// 1. 基线版本：当所有参数都处理完毕时调用。
// 这个函数没有参数，所以它就是递归的终点。
void print_all() {
    std::cout << std::endl; // 打印完所有参数后换行
}

// 2. 递归版本：处理一个参数，然后将剩余的参数包传递给下一次递归。
template<typename T, typename... Args>
void print_all(T first_arg, Args... remaining_args) {
    std::cout << first_arg << " "; // 打印当前参数
    // 递归调用，处理剩余的参数包
    // 这里的 `remaining_args...` 是参数包展开的关键
    print_all(remaining_args...);
}

// 实际使用
// int main() {
//     print_all(1, "hello", 3.14, 'A', true);
//     print_all("Just one argument");
//     print_all(); // 调用基线版本
//     return 0;
// }

print_all(1, "hello", 3.14)

printf

print_all()

std::forward

std::forward

// 假设我们有一个接受右值引用的函数
void process_value(int&& val) {
    std::cout << "Processing rvalue: " << val << std::endl;
}
void process_value(const int& val) {
    std::cout << "Processing lvalue: " << val << std::endl;
}

// 错误的递归传递
template<typename T, typename... Args>
void bad_forward(T first, Args... rest) {
    // 这里的first无论原始是左值还是右值，都会被当做左值传递给process_value
    // 因为first本身是一个具名变量
    process_value(first);
    if constexpr (sizeof...(rest) > 0) { // C++17 if constexpr 简化基线判断
        bad_forward(rest...);
    }
}

// 正确的递归传递，使用std::forward
template<typename T, typename... Args>
void good_forward(T&& first, Args&&... rest) { // 注意这里是万能引用
    // 使用std::forward保持原始值类别
    process_value(std::forward<T>(first));
    if constexpr (sizeof...(rest) > 0) {
        good_forward(std::forward<Args>(rest)...);
    }
}

// int main() {
//     int x = 10;
//     std::cout << "Bad Forward:" << std::endl;
//     bad_forward(x, 20); // x是左值，20是右值。但bad_forward内部都会被视为左值
//     std::cout << "Good Forward:" << std::endl;
//     good_forward(x, 20); // x保持左值，20保持右值
//     return 0;
// }

std::tuple

std::variant

make_unique<T>(args...)

T

std::unique_ptr

template<typename T, typename... Args>
std::unique_ptr<T> make_unique_custom(Args&&... args) {
    // 完美转发所有参数给T的构造函数
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

// class MyClass {
// public:
//     MyClass(int a, std::string b) { /* ... */ }
// };
// auto obj = make_unique_custom<MyClass>(10, "hello");

Signal

Signal

print_all

#include <iostream>
#include <string>

template<typename... Args>
void print_all_folded(Args&&... args) {
    // 这是一个二元右折叠表达式
    // (std::cout << arg1 << ... << argN)
    // 实际上是 (std::cout << arg1) << arg2 << ... << argN
    // 每个arg后面跟一个空格
    ((std::cout << std::forward<Args>(args) << " "), ...);
    std::cout << std::endl;
}

// int main() {
//     print_all_folded(1, "hello", 3.14, 'A', true);
//     print_all_folded("Just one argument");
//     print_all_folded(); // 对于空参数包，这个表达式不会生成任何东西，所以需要注意
//     return 0;
// }

((std::cout << std::forward<Args>(args) << " "), ...)

std::cout

template<typename... Args>
auto sum_all(Args... args) {
    // 二元左折叠，初始值为0
    // ((((0 + arg1) + arg2) + ...) + argN)
    return (0 + ... + args);
}

// int main() {
//     std::cout << sum_all(1, 2, 3, 4) << std::endl; // 输出 10
//     std::cout << sum_all() << std::endl; // 输出 0 (因为0是初始值)
//     return 0;
// }