函数模板的Builder模式：简化多默认模板参数调用

嘿，这个问题我太有共鸣了——C++模板默认参数的顺序限制确实挺烦人的，尤其是参数多的时候，想改后面的参数就得把前面的全写一遍，完全违背了默认参数的初衷。下面这个类似Builder模式的方案应该能完美解决你的需求，让你可以随心所欲地覆盖任意模板参数，不用管顺序和未修改的部分：

问题回顾 #

先再明确下痛点：假设我们有这样一个带一堆默认参数的模板函数：

template<typename T1 = int, typename T2 = float, int X1 = 10, bool B1 = true>
int foo(/* 函数参数 */) {
    // 示例实现：打印参数信息
    std::cout << "T1: " << typeid(T1).name() 
              << ", T2: " << typeid(T2).name() 
              << ", X1: " << X1 
              << ", B1: " << std::boolalpha << B1 << std::endl;
    return 0;
}

如果只想修改X1为42，不得不重复前面所有默认参数：

// 冗余！必须写int、float这些默认值
int x = foo<int, float, 42>(/* 参数 */);

Builder风格解决方案 #

核心思路是用一个参数配置结构体来封装所有模板参数，然后给每个参数提供一个修改方法，返回新的配置实例，最后通过一个方法触发原函数的调用。

1. 定义参数配置结构体

这个结构体保存所有模板参数的当前值（默认或用户修改后的），并提供链式修改的方法：

#include <typeinfo>
#include <iostream>

// 基础参数配置类：封装所有模板参数
template<typename T1 = int, typename T2 = float, int X1 = 10, bool B1 = true>
struct FooConfig {
    // 暴露当前参数的类型/值
    using Type1 = T1;
    using Type2 = T2;
    static constexpr int Value1 = X1;
    static constexpr bool Flag1 = B1;

    // 修改T1：返回新的FooConfig，仅更新T1
    template<typename NewT1>
    [[nodiscard]] auto with_T1() const noexcept {
        return FooConfig<NewT1, Type2, Value1, Flag1>{};
    }

    // 修改T2：返回新的FooConfig，仅更新T2
    template<typename NewT2>
    [[nodiscard]] auto with_T2() const noexcept {
        return FooConfig<Type1, NewT2, Value1, Flag1>{};
    }

    // 修改X1：非类型参数需要用模板参数传递（编译期常量）
    template<int NewX1>
    [[nodiscard]] auto with_X1() const noexcept {
        return FooConfig<Type1, Type2, NewX1, Flag1>{};
    }

    // 修改B1：同理，用模板参数传递编译期布尔值
    template<bool NewB1>
    [[nodiscard]] auto with_B1() const noexcept {
        return FooConfig<Type1, Type2, Value1, NewB1>{};
    }

    // 最终调用原foo函数
    int call(/* 传递原函数的参数 */) const {
        return foo<Type1, Type2, Value1, Flag1>(/* 转发参数 */);
    }
};

2. 辅助入口函数

为了让用户更方便地开始构建，我们提供一个返回默认配置的辅助函数：

// 辅助函数：创建默认参数配置的实例
[[nodiscard]] auto foo_config() noexcept {
    return FooConfig<>{};
}

调用示例 #

现在用户可以用链式调用的方式，任意修改需要的参数，完全不用管未修改的参数和顺序：

int main() {
    // 1. 使用所有默认参数
    foo_config().call();

    // 2. 仅修改X1为42
    foo_config().with_X1<42>().call();

    // 3. 修改T2为double，同时修改B1为false
    foo_config().with_T2<double>().with_B1<false>().call();

    // 4. 修改T1为std::string，X1为100
    foo_config().with_T1<std::string>().with_X1<100>().call();

    return 0;
}

方案优势 #

• 无冗余代码：只需要指定要修改的参数，不用重复默认值
• 顺序无关：想改哪个参数就调用对应的with_*方法，不用记住模板参数的顺序
• 编译期安全：所有参数修改都是编译期完成的，没有运行时开销
• 可读性强：链式调用的语法清晰，一眼就能看出修改了哪些参数

进阶优化建议 #

如果模板参数特别多，手动写每个with_*方法会很繁琐，可以用C的宏或者模板元编程来自动生成这些方法；另外，C20的auto模板参数和概念可以让代码更简洁，比如非类型参数的修改方法可以用auto来推导类型。

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