類模板的可變參數構造函數模板的專門化

Question

這是一個帶有可變參數構造函數的類，它是專門用於從臨時文件複製和移動的類。

template<class Obj> 
    class wrapper { 
    protected: 
     Obj _Data; 
    public: 

     wrapper(const wrapper<Obj>& w): _Data(w._Data) {} 

     wrapper(wrapper<Obj>&& w): 
      _Data(std::forward<Obj>(w._Data)) {} 

     template<class ...Args> 
     wrapper(Args&&... args): 
      _Data(std::forward<Args>(args)...) {} 

     inline Obj& operator()() { return _Data; } 

     virtual ~wrapper() {} 
    }; 

當我使用專業化的一個這樣的

wrapper<int> w1(9); 
wrapper<int> w2(w1); 

，我發現了錯誤：W1的類型推斷爲int。從VS2012

輸出：

error C2440: 'initializing' : cannot convert from 'win::util::wrapper<int>' to 'int' 

如何解決這個問題呢？

Answer 1

你被貪婪的完美轉發構造函數咬住了。

wrapper<int> w2(w1); 

在上面的行中，完善轉發構造是更好的匹配相比拷貝構造爲，因爲Args推導爲wrapper<int>&。

速戰速決的解決辦法是改線以上

wrapper<int> w2(static_cast<wrapper<int> const&>(w1)); 

這個正確調用拷貝構造函數，但是，除了是不必要的冗長，沒有解決根本問題。

要解決原始問題，當Args與wrapper<Obj>相同時，您需要有條件地禁用完美轉發構造函數。

Here's一篇優秀的博客文章，描述問題以及如何解決問題。總之，你需要完美的轉發構造函數定義修改爲

template <typename... Args, 
      DisableIf<is_related<wrapper<Obj>, Args...>::value>...> 
wrapper(Args&&... args): 
    _Data(std::forward<Args>(args)...) {} 

其中is_related被定義爲

template <typename T, typename... U> 
struct is_related : std::false_type {}; 

template <typename T, typename U> 
struct is_related<T, U> : std::is_same<Bare<T>, Bare<U>> {}; 

和Bare是

template <typename T> 
using Bare = RemoveCv<RemoveReference<T>>; 

RemoveCv和RemoveReference是std::remove_cv別名模板和std::remove_reference。

Live demo

Answer 2

編譯器實例化在這條線的構造模板：

wrapper<int> w2(w1); 

由於w1類型是wrapper<int>&和重載決策規則dicate該精確匹配是優選的轉化率。採用const wrapper<Obj>&的構造函數需要const資格，而wrapper<Obj>&&是一個右值引用，它不能綁定到左值。

通常情況下，非模板重載比模板的人（因此在正常情況下的拷貝構造將被選擇）一個優選的目標，但由於構造模板需要universal reference，它可以推斷出類型作爲int製造一個完美的匹配，因此被選中，因此當參數被轉發時出現錯誤。

作爲修復，您可以在某些上下文中通過SFINAE禁用完美轉發構造函數，如this article和@Praetorian's answer中所述。

Answer 3

對我來說，使用的Praetorian的例子更細化的版本爲我工作。 我定義了類似is_compat<T, Arg>的東西，然後將其輸入std::enable_if<>表達式（利用std::decay<>來簡化匹配）。

編輯：發現std::is_convertible，簡單得多。

自包含示例：

• tpl_spec_greedy.cc - 源文件（也使用name_trait.h
• tpl_spec_greedy.output.txt

內嵌例子：

#include <type_traits> 
// Syntactic sugar 
using std::enable_if; 
using std::is_convertible; 
template<bool Expr, typename Result = void> 
using enable_if_t = typename enable_if<Expr, Result>::type; 
template<typename From, typename To> 
using enable_if_convertible_t = enable_if_t<is_convertible<From, To>::value>; 

然後，你可以做的過載，如：

template<typename ... Args> 
void my_func(Args&& ... args) { 
    cout << "1. my_func<Args...>(" << name_trait_list<Args&&...>::join() << ")" << endl; 
} 

// Use template with enable_if to catch as many types as possible 
template<typename T1, 
    typename = enable_if_convertible_t<T1, string>> 
void my_func(int y, T1&& z) { 
    cout 
     << "2. my_func<T1:string>(int, " << name_trait<decltype(z)>::name() 
     << ")" << endl; 
} 

// Example using multiple types (let compiler handle the combinatorics) 
template<typename T1, typename T2, 
    typename = enable_if_t<is_convertible<T1, string>::value && 
          is_convertible<T2, double>::value>> 
void my_func(int y, T1&& z, T2&& zz) { 
    cout 
     << "3. my_func<T1:string, T2:double>(int, " 
     << name_trait<decltype(z)>::name() << ", " 
     << name_trait<decltype(zz)>::name() << ")" << endl; 
} 

（注：name_trait*是一個家庭烘焙類）

輸出示例：

>>> (my_func(1, 2, 5, string("!!!"))); 
1. my_func<Args...>(int&&, int&&, int&&, std::string&&) 

>>> (my_func(3, string("Hello"))); 
2. my_func<T1:string>(int, std::string&&) 

>>> (my_func(4, (const string&)string("kinda"))); 
2. my_func<T1:string>(int, const std::string&) 

>>> (my_func(5, "World")); 
2. my_func<T1:string>(int, const char[6]&) 

>>> (my_func(6, var)); 
2. my_func<T1:string>(int, char[6]&) 

>>> (my_func(7, var, 12)); 
3. my_func<T1:string, T2:double>(int, char[6]&, int&&) 

>>> (my_func(9, var, 12.0)); 
3. my_func<T1:string, T2:double>(int, char[6]&, double&&)