模板实参推导与花括号初始化列表：如何让foo({1,2.0})编译通过？

以下C++代码可以正常编译：

template <typename A, typename B>
struct Pair {
    A a;
    B b;
};

template <typename A, typename B>
void foo(Pair<A, B> p) {
}

int main() {
    foo(Pair{1, 2.0});
}

但如果调用foo时省略Pair，代码会编译失败：

int main() {
    foo({1, 2.0}); // 编译失败：无法推导模板参数
}

需要找到一种模板解决方案，让foo({some_a, some_b})可以正常编译（some_a和some_b可以是任意类型，不强制使用Pair结构体）。

方法1：利用辅助类的模板构造函数 #

定义一个辅助类，通过其模板构造函数捕获两个参数的类型，将初始化列表的构造逻辑转发给实际处理函数：

#include <utility> // 用于std::forward

// 实际处理逻辑的函数
template <typename A, typename B>
void foo_impl(A&& a, B&& b) {
    // 在这里编写你的业务逻辑，比如构造Pair或直接使用a、b
    Pair<std::decay_t<A>, std::decay_t<B>> p{std::forward<A>(a), std::forward<B>(b)};
}

// 辅助类，用于接收初始化列表并推导参数类型
struct PairWrapper {
    template <typename A, typename B>
    PairWrapper(A&& a, B&& b) {
        foo_impl(std::forward<A>(a), std::forward<B>(b));
    }
};

// 对外暴露的foo函数，接受PairWrapper实例
void foo(PairWrapper) {}

int main() {
    foo({1, 2.0});       // 编译通过，支持int+double
    foo({"hello", 3});   // 编译通过，支持const char*+int
}

这个方案的核心是：当调用foo({x,y})时，编译器会尝试用{x,y}构造PairWrapper，而PairWrapper的模板构造函数可以推导出x和y的类型，进而调用实际的处理函数foo_impl。

方法2：C++17类模板推导+重载（保留Pair结构体） #

如果希望继续使用Pair结构体，可以给Pair添加类模板推导指南，再通过重载foo实现初始化列表的自动转换：

template <typename A, typename B>
struct Pair {
    A a;
    B b;
};

// C++17类模板推导指南，让编译器能从两个参数推导出Pair的类型
template <typename A, typename B>
Pair(A, B) -> Pair<A, B>;

// 重载foo，接受Pair实例
template <typename A, typename B>
void foo(Pair<A, B> p) {
    // 处理逻辑
}

int main() {
    foo({1, 2.0}); // 编译通过，编译器自动推导为Pair<int, double>
}

这个方案依赖C++17的类模板推导特性，让编译器能将{x,y}自动推导为Pair的实例。

方法3：C++20概念+结构化绑定（通用Tuple类） #

如果可以使用C++20，还可以利用概念和结构化绑定，支持任意可解构为两个元素的类型（包括std::pair、std::tuple等）：

#include <concepts>
#include <tuple>

template <typename T>
// 约束：T必须是可解构为两个元素的类型
requires requires(T t) {
    { std::get<0>(t) };
    { std::get<1>(t) };
}
void foo(T&& t) {
    auto [a, b] = std::forward<T>(t);
    // 直接使用a和b，类型自动推导
}

int main() {
    foo(std::pair{1, 2.0});    // 编译通过
    foo(std::tuple{"test", 3.14}); // 编译通过
    // 如果要直接使用{1,2.0}，可以配合std::tuple的推导：
    foo(std::tuple{1, 2.0}); // 编译通过
}

这个方案更通用，但需要显式构造std::pair或std::tuple，如果要完全省略类型名，方法1最直接。

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