无法从大括号括起来的初始化列表转换为std元组

Question

作为一个更大的项目的一部分，我正在玩std::tuple和模板; 考虑以下代码：

template <typename ...T> void foo(tuple<T...> t) {}
void bar(tuple<int, char> t) {}
tuple<int, char> quxx() { return {1, 'S'}; }

int main(int argc, char const *argv[])
{
    foo({1, 'S'});           // error
    foo(make_tuple(1, 'S')); // ok
    bar({1, 'S'});           // ok
    quxx();                  // ok
    return 0;
}

根据这个答案， C ++ 17支持从复制列表初始化开始的元组初始化，但是由于我得到以下错误（GCC 7.2.0），所以似乎这种支持是有限的：

main.cpp: In function 'int main(int, const char**)':
main.cpp:14:17: error: could not convert '{1, 'S'}' from '<brace-enclosed initializer list>' to 'std::tuple<>'
     foo({1, 'S'}); // error
                 ^

在这种情况下，我有什么方法可以使用大括号括起来的句法吗？

一些上下文 ：这将在运算符重载中使用，所以我猜我已经绑定了元组并且无法使用可变参数，任何提示都被广泛接受。

额外 ：Clang 6也抱怨

prog.cc:12:5: error: no matching function for call to 'foo'
    foo({1, 'S'});           // error
    ^~~
prog.cc:6:31: note: candidate function [with T = <>] not viable: cannot convert initializer list argument to 'tuple<>'
template <typename ...T> void foo(tuple<T...> t) {}

Answer 1

像{1, 'S'}这样的braced-init-list实际上并没有类型。 在模板推导的上下文中，您只能在某些情况下使用它们 - 当针对initializer_list<T> （其中T是函数模板参数）进行推导时，或者当相应参数已经由其他内容推断时。 在这种情况下，这两件事都不是真的 - 所以编译器无法弄清楚...T应该是什么。

所以你可以直接提供类型：

foo<int, char>({1, 'S'});

或者您可以自己构建tuple并将其传递给：

foo(std::tuple<int, char>(1, 'S')); // most explicit
foo(std::tuple(1, 'S')); // via class template argument deduction

---

今天， ClassTemplate<Ts...>只能从ClassTemplate<Us...>类型的表达式或从类似的东西继承的类型推断出来。 假设的提议可以扩展到另外尝试对表达式执行类模板参数推断以查看该推导是否成功。 在这种情况下， {1, 'S'}不是tuple<Ts...>但是tuple __var{1, 'S'}成功推导出tuple<int, char>以便这样做。 这样的提议还必须解决诸如......如果我们推断ClassTemplate<T, Ts...>或任何微小的变化，这不是类模板参数演绎允许的内容（但是很多东西人们有时表示有兴趣这样做。

我今天不知道这样的建议。

Answer 2

根据这个答案，C ++ 17支持从copy-list-initialization开始的元组初始化，但是看起来这样的支持是有限的，因为我得到以下错误

问题是另一个问题。

当你调用bar({1, 'S'}) ，编译器知道bar()接收一个tuple<int, char> ，所以将1作为int ，将'S'作为char 。

请参阅另一个示例：如果您定义

void baz (std::tuple<int> const &)
 { }

你可以打电话

baz(1);

因为编译器知道baz()接收到std::tuple<int>所以取1来初始化元组中的int 。

但随着

template <typename ...T>
void foo(tuple<T...> t)
 { }

编译器不知道T...类型; 你打电话的时候

foo({1, 'S'}); 

什么T...类型应该推断编译器？

我看到，至少有两个假设： T = int, char或T = std::pair<int, char> ; 或者还有T = std::tuple<int, char> 。

编译器应遵循哪种假设？

我的意思是：如果你将std::tuple传递给foo() ，编译器会接受元组中的类型列表作为T...的列表; 但是如果你传递别的东西，编译器必须推导出正确的std::tuple ; 但在这种情况下，这种推论并不是唯一的。 所以错误。