模板別名

Question

編輯：讓我們suposse我有兩個（或多個）模板函數f和使用g（有時），這取決於它的模板參數類型：

template<typename T> 
some_ugly_and_large_or_deep_template_struct_1<T>::type 
f(const some_ugly_and_large_or_deep_template_struct_1<T>::type&, 
    const some_ugly_and_large_or_deeptemplate_struct_1<T>::type&) 
{ 
    // body, that uses perhaps more times my 
    // "some_ugly_and_large_or_deep_template_struct_1<T>" 
} 

template<typename T> 
some_ugly_and_large_or_deep_template_struct_2<T>::type 
g(const some_ugly_and_large_or_deep_template_struct_2<T>::type&, 
    const some_ugly_and_large_or_deeptemplate_struct_2<T>::type&) 
{ 
    // body, that uses perhaps more times my 
    // "some_ugly_and_large_or_deep_template_struct_2<T>" 
} 

我怎麼能簡化這種「類型」定義？例如使用任何新的C++ 11工具？我認爲只有在這樣的：

template<typename T, 
     typename aux = some_ugly_and_large_or_deep_template_struct_1<T>::type> 
aux f(const aux&, const aux&) 
{ 
    // body, that uses perhaps more times my 
    // "aux" type 
} 

template<typename T, 
     typename aux = some_ugly_and_large_or_deep_template_struct_2<T>::type> 
aux g(const aux&, const aux&) 
{ 
    // body, that uses perhaps more times my 
    // "aux" type 
} 

，我用這種方法看到的問題是，用戶可以提供自己的aux類型，而不是我想要的類型。

Answer 1

如果你讓一個可變參數模板，調用者有沒有可能定義後列出的類型參數：

template<typename T, 
     typename..., // firewall, absorbs all supplied arguments 
     typename aux = some_ugly_and_large_or_deep_template_struct_1<T>::type> 
aux f(const aux&, const aux&) 
{ 
    // body, that uses perhaps more times my 
    // "aux" type 
} 

可選，防止調用f意外太多的模板參數，可以添加一個static_assert ：

template<typename T, 
     typename... F, 
     typename aux = some_ugly_and_large_or_deep_template_struct_1<T>::type> 
aux f(const aux&, const aux&) 
{ 
    static_assert(sizeof...(F)==0, "Too many template arguments"); 
    // body, that uses perhaps more times my 
    // "aux" type 
} 

通常情況下，我可以讓用戶定義喜歡aux類型的生活，是例如返回類型，其中這可以爲您節省演員。

或者你可以用enable_if更換static_assert：

template<typename T, 
     typename... F, typename = typename std::enable_if<sizeof...(F)==0>::type, 
     typename aux = some_ugly_and_large_or_deep_template_struct<T>::type,> 
aux f(const aux&, const aux&) 
{ 
    // body, that uses perhaps more times my            
    // "aux" type                   
} 

Answer 2

一個可能的解決方案是將模板函數轉換爲template struct與operator()。例如：

#include <iostream> 
#include <string> 

template <typename T> 
struct some_ugly_and_large_or_deep_template_struct 
{ 
    typedef T type; 
}; 

template <typename T> 
struct f 
{ 
    typedef typename some_ugly_and_large_or_deep_template_struct<T>::type aux; 

    aux operator()(const aux& a1, const aux& a2) 
    { 
     return a1 + a2; 
    } 
}; 

int main() 
{ 
    std::cout << f<int>()(4, 4) << "\n"; 
    std::cout << f<std::string>()("hello ", "world") << "\n"; 
    return 0; 
} 

Answer 3

你可以宣佈一個模板別名旁邊的功能：

template<typename T> using f_parameter 
    = typename some_ugly_and_large_or_deep_template_struct<T>::type; 

template<typename T> 
f_parameter<T> f(const f_parameter<T>&, const f_parameter<T>&) 
{ 
    f_parameter<T> param; 
} 

Answer 4

您可以在合適的命名空間中使用類似

namespace f_aux { 
    template <typename T> using type = 
      typename some_ugly_and_large_or_deep_template_struct<T>::type; 
} 

template <typename T> 
f_aux::type<T> f(const f_aux::type<T>& , const f_aux::type<T>&); 

如果f的聲明或類，則可能不需要額外的f_aux名稱空間。