覆蓋函數模板專門化中的返回類型

Question

我想專用一個函數模板，以便返回類型根據模板參數的類型而變化。

class ReturnTypeSpecialization 
{ 
public: 
    template<typename T> 
    T Item(); 
}; 

// Normally just return the template type 
template<typename T> 
T ReturnTypeSpecialization::Item() { ... } 

// When a float is specified, return an int 
// This doesn't work: 
template<float> 
int ReturnTypeSpecialization::Item() { ... } 

這可能嗎？我無法使用C++ 11。

Answer 1

由於專業化與返回類型的基本模板的同意，你可以通過添加一個「返回類型特徵」做起來很，一個結構，你可以專注並從中汲取真正的返回類型：

// in the normal case, just the identity 
template<class T> 
struct item_return{ typedef T type; }; 

template<class T> 
typename item_return<T>::type item(); 

template<> 
struct item_return<float>{ typedef int type; }; 
template<> 
int item<float>(); 

Live example.

請注意，你可能要堅持以下，所以你只需要更新的返回類型在item_return專業化。

template<> 
item_return<float>::type foo<float>(){ ... } 
// note: No `typename` needed, because `float` is not a dependent type 

Answer 2

你可以做模板特像這樣：

template<typename T> 
T item() { 
    return T(); 
} 

template<> 
float item<float>() { 
    return 1.0f; 
} 

Answer 3

也許你可以使用下面的技巧。鑑於這些簡單的類型特點：

template<bool b, typename T, typename U> 
struct conditional { typedef T type; }; 

template<typename T, typename U> 
struct conditional<false, T, U> { typedef U type; }; 

template<typename T, typename U> 
struct is_same { static const bool value = false; }; 

template<typename T> 
struct is_same<T, T> { static const bool value = true; }; 

你可以寫出如下類和專業的成員函數：

class ReturnTypeSpecialization 
{ 
public: 
    template<typename T> 
    typename conditional<is_same<T, float>::value, int, T>::type 
    Item(); 
}; 

// Normally just return the template type 
template<typename T> 
typename conditional<is_same<T, float>::value, int, T>::type 
ReturnTypeSpecialization::Item() { return T(); } 

// When a float is specified, return an int 
template<> 
int ReturnTypeSpecialization::Item<float>() { return 1.0f; } 

簡單的測試程序（使用C++ 11只是爲了驗證）：

int main() 
{ 
    ReturnTypeSpecialization obj; 
    static_assert(std::is_same<decltype(obj.Item<bool>()), bool>::value, "!"); 
    static_assert(std::is_same<decltype(obj.Item<float>()), int>::value, "!"); 
} 

這是live example。

Answer 4

做一個工人類的所有專業化，並使用一個簡單的函數作爲包裝將隱含專門化。

#include <iostream> 
using std::cout; 

// worker class -- return a reference to the given value 
template< typename V > struct worker 
    { 
    typedef V const & type; 
    static type get(V const & v) { return v; } 
    }; 

// worker class specialization -- convert 'unsigned char' to 'int' 
template<> struct worker<unsigned char> 
    { 
    typedef int type; 
    static type get(unsigned char const & v) { return v; } 
    }; 

// mapper function 
template< typename V > typename worker<V>::type mapper(V const & v) 
    { 
    return worker<V>::get(v); 
    } 

int main() 
    { 
    char a='A'; 
    unsigned char b='B'; 
    cout << "a=" << mapper(a) << ", b=" << mapper(b) << "\n"; 
    } 

在這個例子中，unsigned char專業化導致它被轉換爲int，使得cout將其顯示爲一個數而不是作爲一個字符，產生以下輸出...

a=A, b=66