C++11：重载无法解析递归 decltype

在下面的代码中，我尝试构建类型网格。例如，之间float and int，将结果推广为float:

float join(float f, int)   { return f; }
float join(float f, float) { return f; }

然后我介绍一个wrapper type:

template <typename Inner>
struct wrapper
{
  using inner_t = Inner;
  inner_t value;
};

谁的行为与join操作相当自然：

template <typename Inner1, typename Inner2>
auto
join(const wrapper<Inner1>& w1, const wrapper<Inner2>& w2)
  -> wrapper<decltype(join(w1.value, w2.value))>
{
  return {join(w1.value, w2.value)};
}

也可以是joined 为“标量”类型：

template <typename Inner1, typename T2>
auto
join(const wrapper<Inner1>& w1, const T2& value2)
  -> wrapper<decltype(join(w1.value, value2))>
{
  return {join(w1.value, value2)};
}

到目前为止，效果很好，有效。但是，因为在实际情况中我实际上有更多这样的规则，所以我想避免重复规则的数量来表达join操作，因此，我表示join(scalar, wrapper) := join(wrapper, scalar)（事实上​​，我更喜欢类似的东西join(v1, v2) := join(v2, v1)，但让我们从更具体的事情开始。）：

template <typename T1, typename Inner2>
auto
join(const T1& value1, const wrapper<Inner2>& w2)
  -> decltype(join(w2, value1))
{
  return join(w2, value1);
}

这适用于join(scalar, scalar), join(wrapper, scalar) and join(scalar, wrapper)。但是之后join(wrapper, wrapper)导致 G++ 4.9 和 Clang++ 3.5 的模板函数无限扩展，我不明白。

int main()
{
  int i;
  float f;
  wrapper<float> fr;
  join(f, i);
  join(fr, i);
  join(i, fr);
  join(fr, fr); // Loops.
}

Clang:

clang++-mp-3.5 -std=c++11 bar.cc
bar.cc:21:5: fatal error: recursive template instantiation exceeded maximum depth of
      256
    join(const wrapper<Inner1>& w1, const T2& value2)
    ^
bar.cc:29:5: note: while substituting deduced template arguments into function
      template 'join' [with T1 = wrapper<float>, Inner2 = float]
    join(const T1& value1, const wrapper<Inner2>& w2)
    ^

GCC:

g++-mp-4.9 -std=c++11 bar.cc
bar.cc:30:34: error: template instantiation depth exceeds maximum of 900 (use -ftemplate-depth= to increase the maximum) substituting 'template<class T1, class Inner2> decltype (join(w2, value1)) join(const T1&, const wrapper<Inner2>&) [with T1 = <missing>; Inner2 = <missing>]'
       -> decltype(join(w2, value1))
                                  ^
bar.cc:30:34:   recursively required by substitution of 'template<class T1, class Inner2> decltype (join(w2, value1)) join(const T1&, const wrapper<Inner2>&) [with T1 = wrapper<float>; Inner2 = float]'
bar.cc:30:34:   required by substitution of 'template<class T1, class Inner2> decltype (join(w2, value1)) join(const T1&, const wrapper<Inner2>&) [with T1 = wrapper<float>; Inner2 = float]'
bar.cc:43:18:   required from here

我不明白为什么重载不会减少递归。到底是怎么回事？可能有一种可能的替代实现（类）模板专门化，但我并不是在寻找替代实现：我想了解这个实现有什么问题。提前致谢。

这有几个问题，其中之一会导致错误。

template <typename Inner1, typename T2>
auto
join(const wrapper<Inner1>& w1, const T2& value2)  // (A)
  -> wrapper<decltype(join(w1.value, value2))>;

名称查找join这里不会通过非限定查找找到相同的函数模板，因为尾随返回类型是声明的一部分，只能找到名称一旦他们have已宣布。但语法允许 ADL 找到相同的函数模板。从属名称的 ADL 稍后执行（从实例化点开始）。

据我了解这个问题，问题来自重载解析：之前decltype(join(w1.value, value2))尝试解析重载时，所有具有该名称的函数模板都需要实例化。对于每个函数模板，都会将一个实例化添加到重载集中（如果实例化成功）。

因此，所有join需要是实例化。实例化包括确定返回类型。对于这个特定的每个实例join函数模板 (A)，具有相同模板参数的相同函数模板 (A) 是重载决策集的候选者。也就是说，要确定(A)有哪种返回类型，需要有一个重载决策，这需要确定(A)的返回类型等等。

推导和替换在递归的任何一步中都不会失败，这是唯一的原因not选择此重载是之间的部分排序不同的调用的函数模板join。并且仅检查部分排序作为...的一部分重载解析过程——为时已晚，无法阻止进一步的实例化。

正如错误消息中提到的，此错误是作为实现限制而发生的。因此，它不属于 SFINAE 类别，请参阅解决表达式的 SFINAE 问题。因此，即使不选择此重载，它的存在也会使程序格式错误，就像

struct tag_for_ADL {};

template<class T>
auto foo(T p) -> decltype(foo(p));

foo(tag_for_ADL{}); // ill-formed, leads to infinite recursive instantiation