कक्षा विधि

Question

के लिए पॉइंटर आंशिक विशेषज्ञता करते समय "स्पष्ट टेम्पलेट तर्कों का अवैध उपयोग" प्राप्त करना हैलो मुझे आंशिक विशेषज्ञता के साथ समस्याएं आ रही हैं। मैं जो करना चाहता हूं वह एक वर्ग है जिसमें टेम्पलेट सदस्य फ़ंक्शन है जो उपयोगकर्ता द्वारा निर्दिष्ट किसी दिए गए मान की व्याख्या करेगा। मिसाल के तौर पर वर्ग के नाम Value है और यहाँ है कि मैं क्या करना चाहते हैं का एक टुकड़ा है:

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

जब मैं संकलन मैं हो रही है निम्नलिखित:

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

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

यहाँ कैसे मैं ऐसे वर्ग को लागू किया है त्रुटि:

:

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

मूल रूप से अपने कोड का सूचक टेम्पलेट भाग के बारे में शिकायत

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

मुझे पता है कि इस समस्या को एक साधारण संघ के साथ कार्यान्वित किया जा सकता है, लेकिन यह कोड एक बड़े कोड का एक अलग संस्करण है।

क्या कोई जानता है कि समस्या क्या हो सकती है? मैं पॉइंटर्स का उपयोग नहीं करते समय पॉइंटर्स और अन्य का उपयोग करते समय अलग-अलग कोड करना चाहता हूं। मैं वास्तव में अटक गया हूं और मैं हमेशा पूछने की बजाय जांच करता हूं, लेकिन मुझे इसके बारे में कोई अच्छी जानकारी नहीं मिली है।

Answer 1

फ़ंक्शन टेम्पलेट्स आंशिक रूप से विशिष्ट नहीं हो सकते हैं, लेकिन अधिकांश समय, आप प्रतिनिधि-से-क्लास चाल का उपयोग कर सकते हैं। आप में उदाहरण के लिए यह होगा:

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