टेम्पलेट से पारित प्रकार स्विच करें

Question

क्या यह टेम्पलेट फ़ंक्शन में पारित प्रकार की जांच करने के लिए सी ++ में संभव है? यह वह जगह है,

template <typename T> 
void Foo() { } 

template <> 
void Foo<SomeClass>() { } 

template <> 
void Foo<SomeClass2>() { } 

// etc. 

(आप नहीं वास्तव में, हालांकि विशेषज्ञ समारोह टेम्पलेट हैं: उदाहरण के लिए:

template <typename T> 
void Foo() 
{ 
    if (typeof(SomeClass) == T) 
     ...; 
    else if (typeof(SomeClass2) == T) 
     ...; 
} 

Answer 1

हां, यह है ... लेकिन शायद यह आपके द्वारा अपेक्षित तरीके से काम नहीं करेगा।

template < typename T > 
void foo() 
{ 
    if (is_same<T,SomeClass>::value) ...; 
    else if (is_same<T,SomeClass2>::value) ...; 
} 

आप अपनी इच्छा/संकलक पर निर्भर करता है std:: या boost:: से is_same मिल सकती है। पूर्व केवल सी ++ 0x में है।

समस्या ... में क्या है के साथ आता है। यदि आप foo के भीतर उन प्रकारों के लिए विशिष्ट कुछ फ़ंक्शन कॉल करने में सक्षम होने की उम्मीद करते हैं, तो आप दुखी हैं। एक कंपाइलर त्रुटि तब भी परिणाम देगी जब कोड का वह अनुभाग कभी नहीं चलाया जाता है जब आप किसी ऐसे इंटरफ़ेस का पालन नहीं करते हैं जो उस अपेक्षित इंटरफ़ेस का पालन नहीं करता है।

उस समस्या को हल करने के लिए आपको कुछ अलग करने की आवश्यकता है। मैं टैग भेजने की सलाह देते हैं:

struct v1_tag {}; 
struct v2_tag {}; 

template < typename T > struct someclass_version_tag; 
template < > struct someclass_version_tag<SomeClass> { typedef v1_tag type; }; 
template < > struct someclass_version_tag<SomeClass2> { typedef v2_tag type; }; 

void foo(v1_tag) { ... } 
void foo(v2_tag) { ... } 
template < typename T > void foo() 
{ 
    typedef typename someclass_version_tag<T>::type tag; 
    foo(tag()); 
} 

ध्यान दें कि आप किसी भी क्रम-बहुरूपता भूमि के ऊपर यहाँ पीड़ित नहीं किया जाएगा और अनुकूलन के साथ यह चालू ही या यहाँ तक कि छोटे कोड आकार और गति में (हालांकि आप shouldn 'परिणाम चाहिए इस बारे में चिंता न करें जब तक कि आप एक प्रोफाइलर नहीं चलाते)।

Answer 2

आप कुछ विशिष्ट प्रकार के आधार पर करना चाहते हैं, टेम्पलेट विशेषज्ञ केवल प्रदर्शनी के लिए। यदि आप कर सकते हैं, तो आप टेम्प्लेट को अधिभारित करना चाहते हैं, या एक विशेष श्रेणी टेम्पलेट में प्रतिनिधि होना चाहते हैं। फ़ंक्शन टेम्पलेट्स को विशेषज्ञता देने से क्यों और कैसे बचें, हर्ब सटर के Why Not Specialize Function Templates?)

Answer 3

हां। आपको type traits का उपयोग करना होगा। उदाहरण के लिए:

#include <boost/type_traits/is_same.hpp> 

template <typename T> 
void Foo() 
{ 
    if ((boost::is_same<T, SomeClass>::value)) 
     ...; 
    else if ((boost::is_same<T, SomeClass2>::value)) 
     ...; 
} 

आप क्या हासिल करने की कोशिश कर रहे हैं पर निर्भर करता है, template specialization का उपयोग कर ज्यादा बेहतर विकल्प हो सकता है।

इसके अलावा, आप कुछ कार्यों/विधियों को सशर्त रूप से सक्षम/अक्षम करने के लिए enable_if/disable_if का उपयोग कर सकते हैं। टाइप ट्राइट्स के साथ इसे संयोजित करने के लिए, उदाहरण के लिए, एक प्रकार के एक प्रकार के लिए एक फ़ंक्शन का उपयोग करना और अन्य प्रकार के प्रकार के लिए अन्य फ़ंक्शन का उपयोग करना होगा।

template<typename T> 
struct Bar { static void foo(); }; 
template<typename T> 
template<> inline void Bar<T>::foo() { 
//generic 
} 
template<> inline void Bar<int>::foo() { 
//stuff for int 
} 
template<> inline void Bar<QString>::foo() { 
//QString 
} 

संपादित हाँ प्रकार लक्षण के साथ, लेकिन यह वास्तव में जरूरत नहीं है:

Answer 4

नहीं है, लेकिन आप आंशिक विशेषज्ञता का उपयोग कर सकते हैं। टाइप_ट्रेट्स उदाहरण संपादित करें।

#include <type_traits> 
template<typename T> void foo() { 
    using std::is_same; 
    if<is_same<T, T2>::value || is_same<T, T1>::value) { 
     /* stuff */ 
    } 
}