C++可变参数完全指南：从基础语法到模板元编程实战

1次阅读

共计 2004 个字符，预计需要花费 6 分钟才能阅读完成。

在 C ++ 中处理可变参数主要有两种方式：传统的 C 风格 va_list 和现代的可变参数模板。每种方法都有其适用场景和潜在问题。

C 风格 va_list：
优点：兼容性好，可以与 C 代码交互
缺点：
1. 完全缺乏类型安全
2. 需要手动管理参数内存
3. 性能较差，需要运行时解析
模板变参：
优点：
1. 完全类型安全
2. 编译期展开，运行时零开销
3. 可与现代 C ++ 特性完美结合
缺点：
1. 编译时间可能增加
2. 错误信息可能晦涩难懂

template<typename... Args>
void log(Args&&... args) {(std::cout << ... << args) << std::endl;
}

template<typename... Args>
void wrapper(Args&&... args) {
    // 完美转发参数
    some_function(std::forward<Args>(args)...);
}

递归展开：

template<typename T>
void print(T t) {std::cout << t << std::endl;}

template<typename T, typename... Args>
void print(T t, Args... args) {
    std::cout << t << " ";
    print(args...);  // 递归调用
}

折叠表达式（C++17）：

template<typename... Args>
void print(Args... args) {(std::cout << ... << args) << std::endl;
}

/**
 * 类型安全的日志函数
 * 支持任意数量、任意类型的参数
 * 自动添加换行
 */
template<typename... Args>
void log(Args&&... args) {
    // C++17 折叠表达式
    (std::cout << ... << std::forward<Args>(args)) << std::endl;
}

// 使用示例
log("Error:", 404, "-", "Not found");

template<typename... Types>
class Tuple;

// 基本情况：空元组
template<>
class Tuple<> {};

// 递归定义
template<typename Head, typename... Tail>
class Tuple<Head, Tail...> : private Tuple<Tail...> {
public:
    Tuple(Head head, Tail... tail)
        : Tuple<Tail...>(tail...), head_(head) {}

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

private:
    Head head_;
};

template<typename... Args,
         typename = std::enable_if_t<(std::is_integral_v<Args> && ...)>>
void print_integers(Args... args) {(std::cout << ... << args) << std::endl;
}

template<typename... Args>
constexpr bool all_integral() {return (std::is_integral_v<Args> && ...);
}

static_assert(all_integral<int, short, long>(), "All types must be integral");