具有依赖类型的 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编译并运行，但使用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 模式将范围解析运算符应用于包的每个成员，如 typename RestT：：SomeType... ？
2. clang 相对于标准是否正确，或者这是一个错误？第二个例子真的比第一个例子更模糊吗？（对于第一个示例，似乎你可以说单个参数重载是模棱两可的，第二个参数用 RestT = 实例化




Answer 1

错误消息已经显示了原因。

当生成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 = <>)

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

请考虑此代码。

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

Answer 2

> < li >是的，很好。 < li>

当前的措辞在这一点上非常明确:在部分订购期间，参数包被完全忽略，因为它没有任何参数([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
  // [...]
}

然而，这不是最佳的。关于变量模板偏序有一个核心问题1395:

CWG同意这个例子应该被接受，把这个例子作为最后的决胜局来处理，比起一个参数包，他更喜欢一个省略的参数。

（第1825期给出了一个更精细的策略。两个编译器都为第一种情况实现此规则;只有海湾合作委员会对第二个（即可以被认为是领先半步）。