"Illegale Verwendung von expliziten Vorlagenargumenten" beim Ausführen einer partiellen Zeigerspezialisierung für eine Klassenmethode

Question

Hallo Ich habe Probleme mit Teilspezialisierung. Ich möchte eine Klasse mit einer Template-Member-Funktion haben, die einen bestimmten Wert auf einen vom Benutzer angegebenen Wert interpretiert. Zum Beispiel ist der Klassenname Value und hier ist ein Ausschnitt von dem, was ich tun möchte:

int *ptr1 = new int; 
*ptr1 = 10; 
Value val1 = ptr1; 
int *ptr2 = val1.getValue<int*>(); 

Value val2 = 1; 
int testVal = val2.getValue<int>(); 

Hier ist, wie ich eine solche Klasse implementiert:

struct Value { 

    Value(void *p) : val1(p){} 
    Value(int i) : val2(i){} 

    template<typename T> 
    T getValue(); 

    void *val1; 
    int val2; 
}; 

template<typename T> 
T* Value::getValue<T*>() { 
    return reinterpret_cast<T*>(val1); 
} 

template<> 
int Value::getValue<int>() { 
    return val2; 
} 

Wenn ich kompilieren Ich erhalte die folgende Fehler:

error C2768: 'Value::getValue' : illegal use of explicit template arguments

im Allgemeinen sein beschwerte sich über die Zeiger Template Teil des Codes:

template<typename T> 
T* Value::getValue<T*>() { 
    return reinterpret_cast<T*>(val1); 
} 

Ich weiß, dass dieses Problem mit einer einfachen Union implementiert werden kann, aber dieser Code ist eine abgespeckte Version eines größeren Codes.

Weiß jemand, was das Problem sein könnte? Was ich tun möchte, ist einen Code für die Verwendung von Zeigern und andere für die Verwendung von Zeigern zu trennen. Ich bin wirklich fest und ich suche immer nach, anstatt zu fragen, aber ich habe keine guten Informationen darüber gefunden.

Answer 1

Funktionsvorlagen können nicht teilweise spezialisiert sein, aber meistens können Sie den delegierten Klassentrick verwenden. In Ihrem Beispiel würde es so sein:

struct Value { 
    template<typename T> 
    T getValue() { 
    return Impl_getValue<T>::call(*this); 
    } 
}; 

template <typename T> 
struct Impl_getValue 
{ 
    static T call(Value &v) { 
    //primary template implementation 
    } 
}; 

template <typename T> 
struct Impl_getValue<T*> 
{ 
    static T* call(Value &v) { 
    return reinterpret_cast<T*>(v.val1); 
    } 
};