Переопределение возвращаемого типа в функции шаблона специализации

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