c++ - 为什么不能为这个嵌套的模板化结构推断出这个函数的模板参数？

Question

我有这个嵌套的模板化结构:

template <typename... Ts>
struct A
{
  template <unsigned i>
  struct B
  {
    int b;
  };
};

编译得很好。

然后我尝试定义这个函数。

template <unsigned i, typename... Ts>
void foo(A<Ts...>::B<i> var)
{
  std::cout << var.b << std::endl;
}

出于某种原因我不完全理解，不会编译。我必须按以下方式更改它才能正常工作。

template <unsigned i, typename... Ts>
void foo(typename A<Ts...>::template B<i> var)
{
  std::cout << var.b << std::endl;
}

但是，当我这样调用它时:

A<int, float>::B<0> var = {0};
foo(var);

它说模板参数i不能被扣除。

我可以通过将模板参数显式添加到函数调用来使其工作:

A<int, float>::B<0> var = {0};
foo<0, int, float>(var);

这是为什么呢？我怎样才能做到不必在函数调用中指定模板参数？

试试代码:https://repl.it/repls/LavenderDefiantOctagons

Answer 1

因为标准是这么说的。

标准是这样说的，因为反转任意编译时映射等同于暂停。

它等同于 Halt，因为模板元编程是图灵完备的。

它是图灵完备的，因为实际上很难制作出非图灵完备的有用编程语言；它是偶然发生的，避免它会导致一种语言需要对看似简单的事情进行烦人的解决方法。

所以一般的问题是确定哪个A A<int, float>::B<0>来自和反转该映射是困难的，因此 C++ 标准表示编译器不会尝试。

如果您编写自己的映射，您就可以做到。首先，你必须意识到 B类型没有“头发”，因为 B 的类型没有任何意义将其附加回 A 的类型用来创建它。我们可以加上“头发”:

template<class...Ts>
struct A {
  template<unsigned i>
  struct B {
    using daddy = A;
    int b;
  };
};

现在我们可以找到A来自 B<?> 的类型.

接下来让我们添加一些逆映射:

 template<class...Ts>
 struct types_t {using type=types_t;};

 template<class X>
 struct get_types;
 template<class X>
 using get_types_t=typename get_types<X>::type;
 template<template<class...>class Z, class...Ts>
 struct get_types<Z<Ts...>>:types_t<Ts...>{};
 template<class B>
 struct get_B_index;
 template<unsigned i, template<unsigned>class B>
 struct get_B_index<B<i>>:std::integral_constant<unsigned, i>{};

从这里我们可以得到A的模板参数来自 B :

 template<class...Ts, unsigned i>
 void foo( types_t<Ts...>, std::integral_constant<unsigned, i>, typename A<Ts...>::template B<i> var ) {
 }
 template<class B>
 void foo( B b ) {
   using types = get_types_t< typename B::daddy >;
   using index = get_B_index< B >;
   return foo( types{}, index{}, b );
 }

Live example