मैं अपनी टेम्पलेट क्लास को एक विशिष्ट क्लैस्स्टइप की जांच कैसे करूं?

Question

मेरे टेम्पलेट-ized फ़ंक्शन में, मैं टाइप टी को एक विशिष्ट प्रकार की जांच करने की कोशिश कर रहा हूं। मुझे यह कैसे करना है?

पी/एस मुझे टेम्पलेट विनिर्देशन तरीका पता था लेकिन मैं ऐसा नहीं करना चाहता।

template<class T> int foo(T a) { 
    // check if T of type, say, String? 
} 

धन्यवाद!

Answer 1

मैं तुम्हें std::type_info typeid ऑपरेटर

Answer 2

प्रकार के उपयोग विशेषज्ञता के लिए जांच करने के बजाय। अन्यथा, टेम्पलेट का उपयोग न करें।

template<class T> int foo(T a) { 
     // generic implementation 
} 
template<> int foo(SpecialType a) { 
    // will be selected by compiler 
} 

SpecialType x; 
OtherType y; 
foo(x); // calls second, specialized version 
foo(y); // calls generic version 

Answer 3

आप type_traits (available in Boost and TR1) (जैसे is_same या is_convertible) का उपयोग करता है, तो क्या तुम सच में विशेषज्ञता से बचना चाहते हैं देख सकते हैं।

Answer 4

द्वारा लौटाए का उपयोग आप के बारे में संकलन समय परवाह नहीं है, तो हो सकता है, तो आप boost::is_same उपयोग कर सकते हैं लगता है। (बढ़ावा प्रकार लक्षण पुस्तकालय को देखने)

bool isString = boost::is_same<T, std::string>::value; 

सी ++ 11 के रूप में, यह अब मानक पुस्तकालय

bool isString = std::is_same<T, std::string>::value 

Answer 5

आप प्रकार है कि आप प्राप्त हुआ है पर स्थिर जांच कर सकते हैं का हिस्सा है , लेकिन जब तक आप एक बिंदु या दूसरे पर विशेषज्ञता (या ओवरलोड, @litb सही ढंग से इंगित करते हैं) का उपयोग नहीं करते हैं, तो आप तर्क प्रकार के आधार पर अलग-अलग विशिष्ट कार्यान्वयन प्रदान नहीं कर पाएंगे।

जब तक आपके पास कोई विशेष कारण नहीं है (जिसे आप प्रश्न में जोड़ सकते हैं) इंटरफ़ेस में विशेषज्ञता का उपयोग न करने के लिए बस विशेषज्ञ करें।

template <> int subtract( std::string const & str); 

Answer 6

मुझे लगता है कोई आपको बता क्यों यह एक अच्छा विचार नहीं हो सकता है अधिक भार या विशेषज्ञता का उपयोग नहीं करना चाहिए। पर विचार करें:

template<class T> int foo(T a) { 
    if(isAString<T>()) { 
    return a.length(); 
    } else { 
    return a; 
    } 
} 

आप एक पहली नजर है कि यह भी int के लिए काम करेंगे क्योंकि यह केवल तार के लिए length फोन करने की कोशिश करेंगे पर सोच सकते हैं। लेकिन वह अंतर्ज्ञान गलत है: संकलक अभी भी स्ट्रिंग शाखा की जांच करता है, भले ही वह शाखा रनटाइम पर नहीं ली जाती है। और यदि आप T एक int है तो आप पाएंगे कि आप गैर-वर्गों पर सदस्य फ़ंक्शन को कॉल करने का प्रयास कर रहे हैं।

यही कारण है कि यदि आपको अलग-अलग व्यवहार की आवश्यकता है तो आपको कोड को अलग करना चाहिए। लेकिन विशेषज्ञता के बजाए ओवरलोडिंग का बेहतर उपयोग करें, क्योंकि यह समझना आसान है कि चीजें इसके साथ कैसे काम करती हैं।

template<class T> int foo(T a) { 
    return a; 
} 

int foo(std::string const& a) { 
    return a.length(); 
} 

आपने व्यवहार के विभिन्न तरीकों के लिए भी कोड को अलग किया है। यह सब अब एक साथ चिपकाया नहीं है। ध्यान दें कि ओवरलोडिंग के साथ, पैरामीटर में अलग-अलग प्रकार के रूप हो सकते हैं और कंपाइलर अभी भी सही संस्करण का उपयोग करेगा यदि दोनों समान मिलान करते हैं, जैसा कि यहां है: कोई संदर्भ हो सकता है, जबकि दूसरा नहीं कर सकता है।

Answer 7

हम्म क्योंकि मैं 'विनिर्देश' हिस्सा जब तक एक ही कोड का एक बड़ा हिस्सा था।

आप अधिक भार का उपयोग कर सकते हैं, लेकिन अगर कोड का एक बड़ा हिस्सा किसी भी प्रकार के लिए काम करेंगे, तो आपको एक अलग समारोह में अलग-अलग हिस्सा निकालने पर विचार करने और ओवरलोड कि हो सकता है।

template <class T> 
void specific(const T&); 

void specific(const std::string&); 

template <class T> 
void something(const T& t) 
{ 
    //code that works on all types 
    specific(t); 
    //more code that works on all types 
} 

Answer 8

आप सी ++ 11 या बाद में, उपयोग कर रहे हैं std :: is_same बिल्कुल वही करती आप क्या चाहते हैं:

template <typename T> 
constexpr bool IsFloat() { return std::is_same<T, float>::value; } 

template <typename T> 
void SomeMethodName() { 
    if (IsFloat<T>()) { 
    ... 
    } 
} 

http://en.cppreference.com/w/cpp/types/is_same