是一個C++ 11 variadic函數模板重載與依賴類型模糊？

Question

下面的代碼是一個遞歸可變參數函數過載的一個典型例子。在這兩種鐺和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使用鐺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. 是鏗鏘正確的面對面的人的標準，或者這是一個錯誤？第二個例子真的比第一個更模糊嗎？ （對於第一個例子，好像你可以說，一個參數超載是曖昧與第二與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

錯誤信息已經顯示出的原因。

當生成加載（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); 
}