मान लीजिए मेरे पास एक टेम्पलेट फ़ंक्शन और दो कक्षाएं हैं
class animal {
}
class person {
}
template<class T>
void foo() {
if (T is animal) {
kill();
}
}
टी के लिए मैं कैसे जांच कर सकता हूं पशु है? मैं कुछ ऐसा नहीं करना चाहता जो रन टाइम के दौरान चेक करे। धन्यवाद
जवाबों:
उपयोग करें is_same:
#include <type_traits>
template <typename T>
void foo()
{
if (std::is_same<T, animal>::value) { /* ... */ } // optimizable...
}
आमतौर पर, यह एक पूरी तरह से काम करने योग्य डिजाइन है, हालांकि, और आप वास्तव में विशेषज्ञ बनना चाहते हैं :
template <typename T> void foo() { /* generic implementation */ }
template <> void foo<animal>() { /* specific for T = animal */ }
ध्यान दें कि स्पष्ट (गैर-कटौती किए गए) तर्कों के साथ फ़ंक्शन टेम्प्लेट होना असामान्य है। यह अनसुना नहीं है, लेकिन अक्सर बेहतर दृष्टिकोण होते हैं।
Tनहीं की गई है, इसलिए बहुत कुछ नहीं है जो आप कर सकते हैं। आप प्राथमिक टेम्पलेट को अनइम्प्लीमेंट करके छोड़ सकते हैं और एक विशेषज्ञता बना सकते हैं, या आप के साथ एक स्थैतिक अभिकथन जोड़ सकते हैं is_same।
मुझे लगता है कि आज, यह उपयोग करने के लिए बेहतर है, लेकिन केवल C ++ 17 के साथ।
#include <type_traits>
template <typename T>
void foo() {
if constexpr (std::is_same_v<T, animal>) {
// use type specific operations...
}
}
यदि आप बिना अभिव्यक्ति शरीर में कुछ प्रकार के विशिष्ट संचालन का उपयोग करते हैं constexpr, तो यह कोड संकलित नहीं करेगा।
std::is_same<T, U>::valueआप कम इस्तेमाल कर सकते हैं:std::is_same_v<T, U>
C ++ 17 में, हम उपयोग कर सकते हैं वेरिएंट का।
काम में लाना std::variant , आपको शीर्ष लेख को शामिल करना होगा:
#include <variant>
उसके बाद, आप std::variantअपने कोड को इस तरह जोड़ सकते हैं :
using Type = std::variant<Animal, Person>;
template <class T>
void foo(Type type) {
if (std::is_same_v<type, Animal>) {
// Do stuff...
} else {
// Do stuff...
}
}
typeजो प्रकार का मूल्य है Typeया एक टेम्पलेट जो यहां समझ में नहीं आता है) is_same_vके संदर्भ में सार्थक नहीं है variant। इसी "लक्षण" है holds_alternative।
std::variantयहाँ पूरी तरह से अनावश्यक है
आप इस तरह से अपने मापदंडों में पारित किए गए के आधार पर अपने टेम्पलेट्स को विशेषज्ञ कर सकते हैं:
template <> void foo<animal> {
}
ध्यान दें कि यह उस प्रकार के आधार पर एक पूरी तरह से नया फ़ंक्शन बनाता है जो इस प्रकार पारित किया गया है T। यह आमतौर पर बेहतर होता है क्योंकि यह अव्यवस्था को कम करता है और अनिवार्य रूप से कारण है कि हमारे पास पहले स्थान पर टेम्पलेट हैं।