递归调用可变参数模板函数重载时的不明确调用

Question

考虑这段代码：

template<typename FirstArg>
void foo()
{
}

template<typename FirstArg, typename... RestOfArgs>
void foo()
{
    foo<RestOfArgs...>();
}

int main()
{
    foo<int, int, int>();
    return 0;
}

当RestOfArgs只有一个元素（{int}）时，由于不明确的调用foo<RestOfArgs...>();而无法编译。

但这编译没有错误：

template<typename FirstArg>
void foo(FirstArg x)
{
}

template<typename FirstArg, typename... RestOfArgs>
void foo(FirstArg x, RestOfArgs... y)
{
    foo(y...);
}

int main()
{
    foo<int, int, int>(5, 6, 7);
    return 0;
}

为什么第一种情况有歧义？

为什么第二种情况没有歧义？

Answer 1

The answer by @ZangMingJie 回答了您在代码中观察到的行为差异。

我发现通过以下更改更容易理解名称解析：

template<typename FirstArg>
void foo()
{
    printf("1\n");
}

template<typename FirstArg, typename SecondArg, typename... RestOfArgs>
void foo()
{
    printf("2\n");
    foo<SecondArg, RestOfArgs...>();
}

int main()
{
    foo<int, int, int>();
    return 0;
}

当使用两个或多个模板参数时，将调用第二个函数。当有一个模板参数时，第一个函数被调用。

Answer 2

在Function template overloading

有很多规则可以判断哪些模板函数更专业（根据给定的参数）。

要点

template<typename> void foo();
template<typename, typename...> void foo();

foo<int>() 不明确，但不是

template<typename T> void foo(T);
template<typename T, typename... Ts> void foo(T, Ts...);

foo(42) 如下：

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

Answer 3

为什么第一种情况有歧义？

RestOfArgs 可以为空。

所以foo<int> 可以实例化为：

template<int>
void foo()
{
}

和

template<int,>
void foo()
{
    foo<>();
}

两者都会编译，所以它是模棱两可的。

其实foo<>()不会编译，但是下次实例化就失败了，所以没关系。

为什么第二种情况没有歧义？

foo<int>(7) 可以实例化为：

template<int>
void foo(int 7)
{
}

和

template<int>
void foo(int 7)
{
    foo();
}

但是第二个是错误的，因为没有foo不带参数，所以唯一的候选者是第一个，所以不会有歧义