Überschreiben Rückgabetyp in Funktionsvorlage Spezialisierung

Question

Ich möchte eine Funktionsvorlage spezialisieren, so dass der Rückgabetyp abhängig vom Typ des Vorlagearguments ändert.

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() { ... } 

Ist das möglich? Ich kann C++ 11 nicht verwenden.

Answer 1

Da die Spezialisierung hat mit der Basisvorlage auf dem Rückgabetyp zu vereinbaren, können Sie es durch Hinzufügen eines „Rückgabetyp Merkmal“, eine Struktur zu machen, so können Sie den wahren Rückgabetyp spezialisiert und zeichnen aus:

// 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.

Beachten Sie, dass Sie auf die folgenden bleiben möchten, so dass Sie nur die Rückkehr-Typ in der item_return Spezialisierung aktualisieren müssen.

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

Answer 2

Sie können wie so Template Spezialisierungen tun:

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

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

Answer 3

Vielleicht könnten Sie den folgenden Hack verwenden. Aufgrund dieser einfachen Art Merkmale:

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; }; 

Sie können Ihre Klasse und Fachelementfunktion wie folgt schreiben:

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; } 

Einfache Testprogramm (verwendet C++ 11 nur für Überprüfung):

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, "!"); 
} 

Hier ist ein live example.

Answer 4

Führen Sie alle Spezialisierungen in einer Worker-Klasse durch und verwenden Sie eine einfache Funktion als Wrapper, der implizit spezialisiert wird.

#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"; 
    } 

In diesem Beispiel verursacht die Spezialisierung der unsigned char es so zu einem int umgewandelt werden, dass es cout als Zahl angezeigt wird, anstatt als ein Zeichen, die folgende Ausgabe erzeugen, ...

a=A, b=66