如何用现代C++等效结构替换C可变参数？求多方案及代码示例

下面是几种替代C风格varargs的现代C++实现方案，均具备类型安全、编译期检查的核心优势：

1. 可变参数模板 + 折叠表达式（C++17及以上） #

利用可变参数模板接收任意数量、任意类型的参数，配合折叠表达式简化参数遍历逻辑，同时通过重载处理不同类型的输出：

#include <iostream>
#include <string>
#include <tuple>
#include <stdexcept>

// 针对不同类型的基础输出重载
void print_arg(int val) {
    std::cout << val << '\n';
}

void print_arg(char val) {
    std::cout << val << '\n';
}

void print_arg(double val) {
    std::cout << val << '\n';
}

// 可变参数模板函数，结合索引序列处理格式与参数的对应关系
template<typename... Args>
void simple_printf(const std::string& fmt, Args&&... args) {
    // 编译期校验参数数量与格式字符串长度匹配
    static_assert(sizeof...(Args) == fmt.size(), "参数数量与格式字符串长度不匹配");

    auto process = [&](auto idx) {
        switch(fmt[idx]) {
            case 'd': 
                print_arg(std::get<idx>(std::forward_as_tuple(std::forward<Args>(args)...))); 
                break;
            case 'c': 
                print_arg(std::get<idx>(std::forward_as_tuple(std::forward<Args>(args)...))); 
                break;
            case 'f': 
                print_arg(std::get<idx>(std::forward_as_tuple(std::forward<Args>(args)...))); 
                break;
            default: 
                throw std::invalid_argument("不支持的格式字符");
        }
    };

    // C++17折叠表达式遍历所有索引
    (process(std::integral_constant<size_t, {}>{}), ...);
}

int main() {
    simple_printf("dcff", 3, 'a', 1.999, 42.5);
}

核心优势 #

• 类型安全：编译期就能检查参数类型是否匹配处理逻辑，避免C varargs的隐式类型转换风险
• 完美转发：避免不必要的参数拷贝，提升性能
• 编译期校验：提前发现参数数量与格式字符串不匹配的问题

2. 使用std::format（C++20及以上） #

C++20引入的标准格式化库，直接复用成熟的类型安全格式化逻辑，无需手动解析格式字符串：

#include <format>
#include <iostream>
#include <string>
#include <stdexcept>

void simple_printf(const std::string& fmt, auto&&... args) {
    // 将自定义格式字符转换为std::format兼容的格式符
    std::string std_fmt;
    for (char c : fmt) {
        switch(c) {
            case 'd': std_fmt += "{}\n"; break;
            case 'c': std_fmt += "{}\n"; break;
            case 'f': std_fmt += "{}\n"; break;
            default: throw std::invalid_argument("不支持的格式字符");
        }
    }
    std::cout << std::vformat(std_fmt, std::make_format_args(std::forward<decltype(args)>(args)...));
}

int main() {
    simple_printf("dcff", 3, 'a', 1.999, 42.5);
}

核心优势 #

• 复用标准库：无需手动实现类型处理逻辑，减少代码冗余
• 扩展性强：支持自定义类型的格式化扩展
• 错误明确：格式或类型不匹配时会抛出清晰的异常

3. 可变参数模板递归（C++11及以上） #

如果需要兼容C++11/14版本，可以用递归方式展开参数包，逐字符解析格式字符串：

#include <iostream>
#include <string>
#include <stdexcept>

// 递归终止函数：无剩余参数时结束
void simple_printf_impl(const std::string::const_iterator&) {}

// 递归处理单个参数与对应格式字符
template<typename T, typename... Args>
void simple_printf_impl(const std::string::const_iterator& fmt_it, T&& val, Args&&... args) {
    switch(*fmt_it) {
        case 'd': std::cout << std::forward<T>(val) << '\n'; break;
        case 'c': std::cout << std::forward<T>(val) << '\n'; break;
        case 'f': std::cout << std::forward<T>(val) << '\n'; break;
        default: throw std::invalid_argument("不支持的格式字符");
    }
    simple_printf_impl(std::next(fmt_it), std::forward<Args>(args)...);
}

// 对外接口函数，添加参数数量校验
template<typename... Args>
void simple_printf(const std::string& fmt, Args&&... args) {
    if (fmt.size() != sizeof...(Args)) {
        throw std::invalid_argument("参数数量与格式字符串长度不匹配");
    }
    simple_printf_impl(fmt.begin(), std::forward<Args>(args)...);
}

int main() {
    simple_printf("dcff", 3, 'a', 1.999, 42.5);
}

核心优势 #

• 兼容性好：支持C11及以上所有现代C版本
• 逻辑直观：逐次处理单个参数与格式字符，易于理解和调试
• 性能优异：无额外库依赖，运行开销低

内容的提问来源于stack exchange，提问作者TestUser