संकलक बनाना गायों को अलग-थलग कर देता है

जैसा कि आप जानते हैं, सी ++ में, साथ ही साथ अपने पूर्वजों सी में, टाइपडीएफ निर्देश नए प्रकार नहीं बनाता है, लेकिन मौजूदा लोगों के लिए सिर्फ उपनाम। और अगर कमजोर टाइप सी में यह कोई समस्या नहीं थी, तो सख्त सी ++ में यह घबराहट पैदा करता है, खासकर शुरुआती लोगों के साथ-साथ कार्यक्रम में मायावी कीड़े।

इस लेख में हम इस अप्रिय विशेषता को प्राप्त करने का प्रयास करेंगे।

आइए एक उदाहरण देखें।

typedef unsigned int galosh_count_t; typedef unsigned int cow_count_t; void print (galosh_count_t count) { std::cout << "   " << count << "  !" << std::endl; } void print (cow_count_t count) { std::cout << "   " << count << " !" << std::endl; } void print (galosh_count_t galosh_count, cow_count_t cow_count) { std::cout << "   " << galosh_count << "    " << cow_count << " !" << std::endl; } int main (int, char*[]) { galosh_count_t galosh_count = 10; cow_count_t cow_count = 15; print (cow_count, galosh_count); //   ,   ,     ,      print (galosh_count); // ,     print (cow_count); // ,     } 

इस उदाहरण में, हमारे पास दो संकलन त्रुटियाँ हैं और एक तार्किक त्रुटि है। और यदि आप एक तर्क के साथ प्रिंट फ़ंक्शन को ओवरलोड करने में असमर्थता के साथ रह सकते हैं, तो तर्कों के गलत आदेश से कार्यक्रम में पूरी तरह से शानदार और मायावी कीड़े हो सकते हैं। कोड को संशोधित करके, ऐसी त्रुटियों का पता लगाना भी बेहद मुश्किल है, और फ़ंक्शन में अधिक तर्क, उतना ही कठिन।

हम संकलक को गायों से अलग करने के लिए सिखाते हैं

तो, कैसे एक उपनाम के बजाय एक नया प्रकार बनाने के लिए typedef पाने के लिए? बेशक, टेम्पलेट्स की मदद से।

प्रयास नंबर 1।

 template <class T> class strong_type { public: explicit strong_type (const T& val) : _val (val) {} strong_type& operator = (const T& val) {_val = val; return *this;} private: T _val; }; typedef strong_type<unsigned int> galosh_count_t; typedef strong_type<unsigned int> cow_count_t; 

यह काम नहीं करेगा, galosh_count_t और cow_count_t सभी एक ही प्रकार के हैं, क्योंकि कंपाइलर strong_type क्लास को केवल एक बार अहस्ताक्षरित int पैरामीटर के साथ त्वरित करता है।

कंपाइलर एक नया प्रकार बनाने के लिए, हम अपने टेम्पलेट में एक और तर्क जोड़ेंगे।

प्रयास नंबर 2।

 template <class T, class Tag> class strong_type { public: explicit strong_type (const T& val) : _val (val) {} strong_type& operator = (const T& val) {_val = val; return *this;} private: T _val; }; typedef strong_type<unsigned int, class TAG_galosh_count_t> galosh_count_t; typedef strong_type<unsigned int, class TAG_cow_count_t> cow_count_t; 

तो हमारे पास दो अलग प्रकार के galosh_count_t और cow_count_t हैं। अब संकलक गंदा मुझ पर कसम खाता है अगर मैं अचानक तर्कों के क्रम को भ्रमित करता हूं और इसके विपरीत ओवरलोड कार्यों की अस्पष्टता के बारे में शिकायत नहीं करूंगा।

कृपया ध्यान दें कि हमें TAG_galosh_count_t और TAG_cow_count_t वर्गों को परिभाषित करने की आवश्यकता नहीं है, वे केवल अद्वितीय टैग के रूप में उपयोग किए जाते हैं।

हालांकि, अंत में काम करने के हमारे उदाहरण के लिए, हमें << ऑपरेटर को फिर से लोड करना होगा।

 template <class T, class Tag> class strong_type { public: explicit strong_type (const T& val) : _val (val) {} strong_type& operator = (const T& val) {_val = val; return *this;} template <class Stream> Stream& operator << (Stream& s) const { s << _val; return s; } private: T _val; }; typedef strong_type<unsigned int, class TAG_galosh_count_t> galosh_count_t; typedef strong_type<unsigned int, class TAG_cow_count_t> cow_count_t; 

एक वास्तविक कार्यक्रम में, निश्चित रूप से, आपको अंकगणित और तार्किक संचालकों को भी अधिभार देना होगा, ताकि गायों और गालोशों को जोड़ा, घटाया और तुलना की जा सके। मुझे लगता है कि आप इसे खुद संभाल सकते हैं।