SFINAE和模板函數實例化：爲什麼在使用具有SFINAE的類型的函數參數中使用模板參數時不能推導出來？

Question

這些天我在用SFINAE做實驗，還有一些讓我感到困惑。爲什麼my_type_a不能在my_function的實例化中推導出來？

class my_type_a {}; 

template <typename T> 
class my_common_type { 
public: 
    constexpr static const bool valid = false; 
}; 

template <> 
class my_common_type<my_type_a> { 
public: 
    constexpr static const bool valid = true; 
    using type = my_type_a; 
}; 

template <typename T> using my_common_type_t = typename my_common_type<T>::type; 

template <typename T, typename V> 
void my_function(my_common_type_t<T> my_cvalue, V my_value) {} 

int main(void) { 
    my_function(my_type_a(), 1.0); 
} 

G ++給了我這樣的：

/home/flisboac/test-template-template-arg-subst.cpp: In function ‘int main()’: 
/home/flisboac/test-template-template-arg-subst.cpp:21:30: error: no matching function for call to ‘my_function(my_type_a, double)’ 
    my_function(my_type_a(), 1.0); 
          ^
/home/flisboac/test-template-template-arg-subst.cpp:18:6: note: candidate: template<class T, class V> void my_function(my_common_type_t<T>, V) 
void my_function(my_common_type_t<T> my_type, V my_value) {} 
     ^~~~~~~~~~~ 
/home/flisboac/test-template-template-arg-subst.cpp:18:6: note: template argument deduction/substitution failed: 
/home/flisboac/test-template-template-arg-subst.cpp:21:30: note: couldn't deduce template parameter ‘T’ 
    my_function(my_type_a(), 1.0); 
          ^

我所期待的是，在調用my_function當我在main一樣，T會被推斷爲函數的第一個參數的類型，以及該類型將用於函數的實例化。但似乎my_common_type_t<T>是函數之前實例化，但即使如此，中my_cvalue類型將成爲my_type_a反正，所以我不明白爲什麼這是行不通的......

是否有不同的方式來做到這一點？我應該避免兩個（或更多）級別的模板間接？

Answer 1

那麼，考慮一下：

template <> 
struct my_common_type<int> { 
    constexpr static const bool valid = true; 
    using type = my_type_a; 
}; 

template <> 
struct my_common_type<double> { 
    constexpr static const bool valid = true; 
    using type = my_type_a; 
}; 

// ... 

int main(void) { 
    my_function(my_type_a{}, 1.0); 
} 

該編譯器選擇my_common_type<int>或my_common_type<double>？

如果語言允許在您的情況下扣除，它將必須匹配將在my_common_type<T>::type爲了產生您發送到函數參數的確切類型。顯然，這不僅是不可能的，但以上面的例子來說，它可能有多種選擇！

幸運的是，有一種方法可以告訴編譯器my_common_type<T>將始終屈服於T。技巧的基本原理是這樣的：

template<typename T> 
using test_t = T; 

template<typename T> 
void call(test_t<T>) {} 

int main() { 
    call(1); 
} 

什麼是T推演？簡單！編譯器對這種匹配很滿意。此外，由於test_t不能專業化，因此test_t<soxething>僅爲something。

template<typename T> 
using test_t = T; 

template<typename T> 
using test2_t = test_t<T>; 

template<typename T> 
void call(test2_t<T>) {} 

int main() { 
    call(1); // will also work 
} 

我們可以將此到你的情況，但我們需要一些工具：

template<typename T, typename...> 
using first_t = T; 

這是一樣的容易

此外，這與別名的多層次的工作壓力太大如上所述匹配，但我們也可以發送一些不會被使用的參數。我們將在這個未使用的包中製作sfinae。

現在，改寫my_common_type_t仍然是一件容易的比賽，而在未使用的包添加約束：

template <typename T> 
using my_common_type_t = first_t<T, typename my_common_type<T>::type>; 

注意，這也是工作：

template <typename T> 
using my_common_type_t = first_t<T, std::enable_if_t<my_common_type<T>::valid>>; 

現在扣將發生，因爲預期！Live (GCC)Live (Clang)

注意，這一招將與C++ 14在這種情況下，只有工作，因爲SFINAE（丟棄參數）時，才能保證，因爲C++ 14的情況發生。

另請注意，您應該爲您的特徵使用struct，或者使用public:來公開成員my_common_type<T>::type，否則GCC將輸出一個僞造錯誤。