使用可变参数模板进行隐式转换

尝试简化一下您的示例并考虑一下：

#include<utility>
template<typename T>
void foo(std::pair<char*, T>) {}
int main() {
foo({"a", 1});
}

如您所见，它无法编译。
问题是{ "a", 1 }不是std::pair，即使你可以从中构造一个

#include<utility>
void foo(std::pair<char*, int>) {}
int main() {
foo({"a", 1});
}

错误很明显：

无法推断模板参数"T">

你为什么不能？

一旦知道T，编译器就可以构造这样的一对。无论如何，必须推导T，编译器无法做到这一点{ "a", 1 }因为这不是可以推导它的对。
无论如何，{ "a", 1 }可以转换为一对，在特定情况下转换为std::pair<char *, T>的专业化，但首先必须推断出T。
从什么推导？当然是一对，但你还没有一对。
依此类推，在一个循环中。

现在让我们讨论一下你尝试做一些涉及可变参数模板的类似事情：不用说，如果上面显示的更简单的例子不能编译，它的可变参数扩展(如果有的话)也不会编译，原因或多或少是相同的。

有没有办法为任意数量的参数对编写函数foo？

我会说不，除非你使用对作为foo的参数.
它遵循一个最小的工作示例：

#include<utility>
template <typename... Args>
void foo(std::pair<const char*, Args>&&...) {}
int main() {
foo(std::make_pair("a", 1), std::make_pair("b", "value"));
}

如果你愿意，你也可以推导出第一个参数，只要它的类型是固定的：

#include<utility>
template <typename T, typename... Args>
void foo(std::pair<T, Args>&&...) {}
int main() {
foo(std::make_pair("a", 1), std::make_pair("b", "value"));
}

否则，如果未修复，您可以执行此操作：

#include<utility>
template <typename... First, typename... Second>
void foo(std::pair<First, Second>&&...) {}
int main() {
foo(std::make_pair("a", 1), std::make_pair(0, "value"));
}

有没有办法为任意数量的参数编写函数foo。 对？

有一些基于可变参数模板的解决方案，但参数必须是成对的，以允许编译器推断类型。那么这样的事情可能会起作用：

template<typename... Args>
void foo() {}
template<typename T, typename U, typename... Args>
void foo(const std::pair<T, U>& p, Args... args) {
std::cout << __PRETTY_FUNCTION__ << std::endl;
foo(args...);
}

所以对于：

foo(std::make_pair("a", 1), std::make_pair("b", "value"), std::make_pair("c", 1.0));

输出(使用 clang 3.8)为：

void foo(const std::pair<T, U> &, Args...) [T = const char *, U = int, Args = <std::__1::pair<const char *, const char *>, std::__1::pair<const char *, double>>]
void foo(const std::pair<T, U> &, Args...) [T = const char *, U = const char *, Args = <std::__1::pair<const char *, double>>]
void foo(const std::pair<T, U> &, Args...) [T = const char *, U = double, Args = <>]

这是完整的工作示例。

要扩展一下 Edgar Rokyan 的答案，您可以将对创建移动到foo函数中：

template<typename... Args>
void foo() {}
// Forward declaration
template<typename U, typename... Args>
void foo(const char * str, U u, Args... args);
// When given a pair
template<typename U, typename... Args>
void foo(const std::pair<const char *, U>& p, Args... args) {
std::cout << p.first << " = " << p.second << std::endl;
foo(args...);
}
// when given a C string and something else, make a pair
template<typename U, typename... Args>
void foo(const char * str, U u, Args... args) {
foo(std::make_pair(str, u), args...);
}

然后你可以这样称呼它：

foo("hi", 42,
"yo", true,
std::make_pair("Eh", 3.14),
"foo", false,
some_pair);

在 c++17 中，您可以通过使用构造函数的模板推导来解决此问题并欺骗编译器：

#include <iostream>
#include <utility>
template <class... Args>
struct P:std::pair<Args...> {
P(Args... args):std::pair<Args...>(args...) { }
};
template <class... Args>
void foo(std::pair<const char *, Args>&&...) {
}
int main() {
foo(P{"abc", 1}, P{"abc", "abc"}, P{"abc", 2.0});
}

[现场演示]