2012-06-13 17 views
10

पर आधारित विभिन्न विधियों का पालन करें क्या टेम्पलेट में पास किए गए चर के प्रकार को निर्धारित करने का कोई तरीका है और यदि यह int या std::string आदि पर आधारित फ़ंक्शन को कॉल करने का कोई तरीका है ...?टेम्पलेट वैरिएबल प्रकार

उदाहरण

template <class T> 
struct Jam 
{ 
    Jam(T *var) 
    { 
     if (typeid(var) == typeid(std::string*) 
       *var = "Hello!"; 
     else if (typeid(var) == typeid(int*) 
       *var = 25; 
    } 
}; 

के लिए जब मैं उस कोड का उपयोग करने का प्रयास करें, मैं एक त्रुटि invalid conversion from const char* to int मिलता है। मुझे संदेह है क्योंकि यह संकलक टेम्पलेट को अलग-अलग कार्यों में "विस्तारित करता है" और जब मैंने संरचना throw Jam<std::string>(&setme); संरचना का एक नया उदाहरण निर्दिष्ट किया, तो यह var* = 25 कथन का पता चला और संकलन करने से इंकार कर दिया।

क्या ऐसा करने का कोई उचित तरीका है? शायद मैक्रो गार्ड के साथ? धन्यवाद।

उत्तर

12

नियमित समारोह के बजाय अधिक भार का उपयोग करें:

template <class T> 
struct Jam 
{ 
    Jam(std::string* var) 
    { 
     *var = "Hello!"; 
    } 

    Jam(int* var) 
    { 
     *var = 25; 
    } 
}; 

जब तक आप प्रकार TJam का दृष्टांत के लिए इस्तेमाल किया पर विशेषज्ञ करना चाहते हैं। उस स्थिति में आप करेंगे:

template<> 
struct Jam<std::string> 
{ 
    Jam(std::string* var) 
    { 
     *var = "Hello!"; 
    } 
}; 

template<> 
struct Jam<int> 
{ 
    Jam(int* var) 
    { 
     *var = 25; 
    } 
}; 


template<typename T> 
struct Jam 
{ 
    Jam(T* var) 
    { 
     // every other type 
    } 
}; 
+1

उदाहरण के लिए अन्य विकल्प हैं, उदाहरण के लिए केवल कन्स्ट्रक्टर ('टेम्पलेट <> जाम :: जाम (int * var) {}' टेम्पलेट क्लास परिभाषा के बाहर) या कोड के आधार पर सक्षम/अक्षम करने के लिए अधिक जटिल SFINAE टेम्पलेट तर्कों पर ... मुझे नहीं लगता कि यह इस साधारण समस्या में समझ में आता है, लेकिन यह समझ में आ सकता है जब ये सरल समाधान बोझ बन जाते हैं (कहें कि कन्स्ट्रक्टर ने 100 चीजें की हैं, जिनमें से केवल एक प्रकार पर निर्भर है , या कि 100 अन्य सदस्य कार्य थे और पूरे प्रकार का विशेषज्ञता महंगा होगा) –

6

"आंशिक टेम्पलेट विशेषज्ञता" देखें।

लें जैम() के जाम {} से बाहर शरीर:

template <class T> 
struct Jam 
{ 
    Jam(T *var); 
}; 

अब दो शरीर लिखें:

Jam<int>::Jam(int *var) { 
    // stuff 
} 

Jam<std::string>::Jam(std::string *var) { 
    // stuff 
} 

(चेतावनी:। रस्टी सी ++ लेकिन वह आम तौर पर आप इसे कैसे करते हैं।)

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

+1

+1, हालांकि यह आमतौर पर * आंशिक * टेम्पलेट विशेषज्ञता के रूप में जाना जाता है। * आंशिक * आंशिक टेम्पलेट विशेषज्ञता * आमतौर पर इस तथ्य को संदर्भित करता है कि * पूर्ण विशेषज्ञता * की तुलना में विशेषज्ञता केवल प्रकार के उप-समूह पर लागू होती है, जिसके लिए सभी टेम्पलेट तर्क तय किए जाते हैं। –

+2

पवित्र बकवास। मुझे सी ++ पता था? उम्मीद है कि कुछ भी विस्फोट नहीं हुआ! – Phlip

+0

@Phlip मैंने बस एक स्पेस शटल लॉन्च में अपना कोड इस्तेमाल किया। यह आग पर पकड़ा गया, हर किसी को मार डाला, और एक शहर को नष्ट कर दिया, सब कुछ आपके कोड के कारण। बहुत बहुत धन्यवाद। – Andrew

संबंधित मुद्दे