模糊重载 - 带有参数包的部分函数模板排序

Question

考虑以下人为设计的代码：

template <class... > struct pack { };

template <class R, class T, class... Args>
int foo(pack<T>, Args...)
{
    return sizeof(R);
}

template <class R, class T, class... Ts, class... Args>
int foo(pack<T, Ts...>, Args... args)
{
    return foo<T>(pack<Ts...>{}, args...);
}

int main() {
    // gcc: OK, clang: ambiguous
    foo<int>(pack<int>{});

    // gcc: ambiguous, clang: ambiguous
    foo<int>(pack<int>{}, 0);
}

如果将第二个重载更改为采用至少 2 种类型的包而不是至少一种类型的包，则 gcc 和 clang 都接受这两个调用：

template <class R, class T, class T2, class... Ts, class... Args>
int foo(pack<T, T2, Ts...>, Args... args)
{
    return foo<T>(pack<T2, Ts...>{}, args...);
}

如果将非推导模板参数移动到推导模板参数，则：

template <class... > struct pack { };

template <class R, class T, class... Args>
int foo(pack<R>, pack<T>, Args...)
{
    return sizeof(R);
}

template <class R, class T, class... Ts, class... Args>
int foo(pack<R>, pack<T, Ts...>, Args... args)
{
    return foo(pack<T>{}, pack<Ts...>{}, args...);
}

int main() {
    // gcc ok with both, clang rejects both as ambiguous
    foo(pack<int>{}, pack<int>{});
    foo(pack<int>{}, pack<int>{}, 0);
}

我希望在每个版本中所有调用都正常。上述代码示例的预期结果是什么？

Answer 1

我现在相信 clang 拒绝是正确的，而 gcc 接受它所接受的那些形式是不正确的。这是一个简化的示例：

template <class...> struct pack { };

// (1)
template <class T>
void foo(pack<T> ) { }

// (2)
template <class T, class... Ts>
void foo(pack<T, Ts...> ) { }

int main() {
    foo(pack<int>{});
}

两个重载都是有效的，从 (1) 推导出 (2) 直接成功。唯一的问题是我们能否从 (2) 中推导出 (1)。我最初不认为...但是 [temp.deduct.type]/9 状态：

如果P 的表单包含<T> 或<i>，则P 的相应模板参数列表的每个参数P_i 是与A的对应模板实参列表的对应实参A_i比较。 [...] 在部分排序期间 (14.8.2.4)，如果 A_i 最初是一个包扩展：
— 如果P 不包含对应于 A_i 的模板参数，则忽略 A_i；

所以当我们为<T, Ts...>（比如<U, Xs...>）合成类型时，我们推导出T=U，然后没有模板参数对应于包扩展Xs...，所以我们忽略它。所有未被忽略的模板参数模板推导成功，所以我们认为从（2）推导（1）是成功的。

由于推导在两个方向上都成功，因此没有一个函数模板被认为比另一个更专业，并且调用应该是模棱两可的。

---

我还没有提交错误报告，等待社区的确认。

Answer 2

我们先把问题简单化考虑

template <class...> struct pack {};

template <class T>
void foo(pack<T>) {}

template <class T, class... Ts>
void foo(pack<T,Ts...>) {}

int main() {
  foo(pack<int>{});
}

哪个clang抱怨并拒绝编译，声称有 void foo(pack<T>) [with T=int] 和 void foo(pack<T,Ts...>) [with T=int, Ts=<>] 之间的歧义。像这样的情况可以使用partial ordering of overloaded function templates 解决，它本质上是试图找到最专业的重载。

在手头的情况下，我认为以下适用：

在平局的情况下，如果一个函数模板有一个尾随参数包而另一个没有，则认为带有省略参数的模板比带有空参数包的模板更专业。强>

因此，似乎应该首选第一个，而 clang 是错误的。