在下面的代码中，我尝试构建一个类型格。例如，在 float 和 int 之间，将结果提升为 float:

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

然后我引入一个wrapper类型:

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)};
}

它也可以用“标量”类型加入:

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) 和 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)
    ^

海湾合作委员会:

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 的名称查找不会通过非限定查找找到相同的函数模板，因为 trailing-return-type 是声明的一部分，名称可以只有在它们已被声明后才能找到。但是语法允许 ADL 找到相同的函数模板。依赖名称的 ADL 稍后执行(从实例化开始)。

据我所知，问题来自重载解析:在 decltype(join(w1.value, value2)) 尝试解析为重载之前，所有具有该名称的函数模板需要实例化。对于每个函数模板，一个实例化被添加到重载集中(如果实例化成功)。

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

演绎和替换在递归的任何一步都不会失败，不选择此重载的唯一原因是不同函数模板之间的部分排序称为加入。并且部分排序仅作为重载解析过程的一部分进行检查——这已经太晚了，无法阻止进一步的实例化。

如错误消息中所述，此错误作为实现限制出现。因此，它不属于 SFINAE 类别，参见 Solving the SFINAE problem for expressions .因此，即使未选择此重载，它的存在本身也会使程序格式错误，就像

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

关于C++11:重载无法解析递归 decltype，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/21813845/