具有依赖类型的 c++11 可变参数函数模板重载是否不明确？

Question

以下代码是递归可变参数函数重载的教科书示例。在 clang 和 GCC 中，它都能干净地编译，main 返回 36（如预期的那样）：

template <typename T>
int add(T val)
{
    return val;
}

template <typename FirstTypeT, typename... RestT>
int add(FirstTypeT first_value, RestT... rest)
{
    return first_value + add<RestT...>(rest...);
}

int main(void)
{
    return add(12, 12, 12);
}

但是，这里稍作修改。它在模板定义中使用依赖类型，而不是直接使用模板参数：

struct Foo
{
    using SomeType = int;
};

template <typename T>
int add(typename T::SomeType val)
{
    return val;
}

template <typename FirstT, typename... RestT>
int add(typename FirstT::SomeType first_value, typename RestT::SomeType... rest)
{
    return first_value + add<RestT...>(rest...);
}

int main(void)
{
    return add<Foo, Foo, Foo>(12, 12, 12);
}

它使用 GCC 5.2 按预期编译和运行，但 fails 使用 clang 3.8：

clang++ variadic.cpp -o var -std=c++11 -Wall
variadic.cpp:15:26: error: call to 'add' is ambiguous
    return first_value + add<RestT...>(rest...);
                         ^~~~~~~~~~~~~
variadic.cpp:15:26: note: in instantiation of function template specialization 'add<Foo, Foo>' requested here
    return first_value + add<RestT...>(rest...);
                         ^
variadic.cpp:20:12: note: in instantiation of function template specialization 'add<Foo, Foo, Foo>' requested here
    return add<Foo, Foo, Foo>(12, 12, 12);
           ^
variadic.cpp:7:5: note: candidate function [with T = Foo]
int add(typename T::SomeType val)
    ^
variadic.cpp:13:5: note: candidate function [with FirstT = Foo, RestT = <>]
int add(typename FirstT::SomeType first_value, typename RestT::SomeType... rest)
    ^
1 error generated.

我的问题是双重的。

1. 像typename RestT::SomeType... 中那样将作用域解析运算符应用于包的每个成员是否真的有效使用参数包类型名模式？
2. clang 相对于标准是否正确，或者这是一个错误？第二个例子真的比第一个更模棱两可吗？ （对于第一个示例，您似乎可以说单参数重载与用 RestT = <> 实例化的第二个参数不明确）

Answer 1

1. 是的，没关系。

2. 目前的措辞非常明确：在部分排序期间完全忽略参数包，因为它没有参数 ([temp.deduct.partial]/(3.1))。 [temp.func.order]/5 也给出了一个非常切题的例子，即使有可推导的模板参数 - 表明你的第一个例子也是模棱两可的：

   [ 注意：由于调用上下文中的偏序只考虑具有显式调用参数的参数，因此忽略某些参数（即函数参数包、具有默认参数的参数、 和省略号参数）。 [...] [ 示例：

   template<class T, class... U> void f(T, U ...);  // #1
   template<class T            > void f(T       );  // #2
   
   void h(int i) {
     f(&i); // error: ambiguous
     // [...]
   }
   

   但是，这不是最优的。可变参数模板部分排序上有core issue 1395：

   CWG 同意该示例应该被接受，将这种情况作为迟到的决胜局处理，更喜欢省略参数而不是参数包。

   (Issue 1825 给出了更精细的策略。) 两个编译器都为第一种情况实现了这个规则；只有 GCC 对第二个有作用（即可以认为是领先了半步）。

Answer 2

错误信息已经说明了原因。

生成add(12)时，有两个可用的模板函数。那是

template <typename T>
int add(typename T::SomeType val);

和

template <typename FirstT, typename... RestT>
int add(typename FirstT::SomeType first_value, typename RestT::SomeType... rest);
// and RestT is empty here(RestT = <>)

这不是标准用法，clang 是正确的。

考虑一下这段代码。

#include <tuple>
#include <type_traits>

struct Foo
{
    using SomeType = int;
};

// helper function to sum a tuple of any size
template<typename Tuple, std::size_t N>
struct TupleSum {
    typedef typename std::tuple_element<N - 1, Tuple>::type ref_t;
    typedef typename std::remove_reference<ref_t>::type noref_t;

    static noref_t sum(const Tuple& t) 
    {
        return std::get<N - 1>(t) + TupleSum<Tuple, N - 1>::sum(t);
    }
};

template<typename Tuple>
struct TupleSum<Tuple, 1> {
    typedef typename std::tuple_element<0, Tuple>::type ref_t;
    typedef typename std::remove_reference<ref_t>::type noref_t;

    static noref_t sum(const Tuple& t) 
    {
        return std::get<0>(t);
    }
};

template <typename... RestT>
int add(typename RestT::SomeType... rest) {
    typedef decltype(std::forward_as_tuple(rest...)) tuple_t;
    return TupleSum<tuple_t, sizeof...(RestT) >::sum(std::forward_as_tuple(rest...));
}

int main(void)
{
    return add<Foo, Foo, Foo>(12, 12, 12);
}