Utility (C++)
सी + + मानक पुस्तकालय में एक शीर्षलेख फ़ाइल है। इस फ़ाइल के दो प्रमुख घटक हैंः, एक नेमस्पेस जिसमें टेम्प्लेट का सेट होता है जो रिलेशनल ऑपरेटरों के लिए डिफ़ॉल्ट व्यवहार को परिभाषित करता है, और उपयोगकर्ता-परिभाषित ऑपरेटरों के आधार पर एक ही प्रकार की वस्तुओं के बीच और। एक पात्र टेम्पलेट जिसमें मनमाने प्रकार की दो सदस्य वस्तुएँ (और) होती हैं। इसके अतिरिक्त, हेडर एस के लिए डिफ़ॉल्ट रिलेशनल ऑपरेटरों को परिभाषित करता है जिनमें दोनों प्रकार समान हैं। आर. एल. ओ. पी. एस. जी. सी. सी. का कार्यान्वयन नेमस्पेस (नेस्टेड) को निम्नलिखित तरीके से घोषित करता हैः नेमस्पेस आर. एल. ओ. पी. एस. {टेम्पलेट <क्लास _ टी. पी.> इनलाइन बूल ऑपरेटर! = (कॉन्स्ट _ टी. पी. & _ _ एक्स, कॉन्स्ट _ टी. पी. & _ _ वाई) {रिटर्न! (_ _ x = = _ _ y);} टेम्पलेट <क्लास _ Tp> इनलाइन बूल ऑपरेटर> (कॉन्स्ट _ Tp & _ x, कॉन्स्ट _ Tp & _ y) {रिटर्न _ _ y <_ x;} टेम्पलेट <क्लास _ Tp> इनलाइन बूल ऑपरेटर <= (कॉन्स्ट _ Tp & _ x, कॉन्स्ट _ Tp & _ y) {रिटर्न! (_ _ y <_ _ x);} टेम्पलेट <क्लास _ Tp> इनलाइन बूल ऑपरेटर> = (कॉन्स्ट _ Tp & _ x, कॉन्स्ट _ Tp & _ y) {रिटर्न! (_ _ x <_ _ y);} की निम्नलिखित घोषणा पर विचार करें, जो समान प्रकार की अन्य वस्तुओं की तुलना के लिए समानता और कम-से-कम प्रचालक को परिभाषित करता हैः वर्ग A {पूर्णांक इमारत; पूर्णांक कमरा; सार्वजनिकः बूल प्रचालक = = (स्थिरांक A और अन्य) स्थिरांक {वापसी (इमारत = other.building) और & (कमरा = = other.room);} बूल प्रचालक <(स्थिरांक A और अन्य) स्थिरांक {वापसी (इमारत <other.building)।। (! (other.building <इमारत) & & (कमरा <other.room));}; शून्य f1 (स्थिरांक A & a1, स्थिरांक A & a2) {बूल बराबर = (a1 = = a2);// उपयोग = = वर्ग A के भीतर परिभाषित बूल बराबर नहीं = (a1! = a2);// त्रुटिः 'प्रचालक के लिए कोई मिलान नहीं! =' में 'a1! = a2' बूल कम = (a1 <a2);// उपयोग <वर्ग A के भीतर परिभाषित बूल बड़ा = (a1> a2);// त्रुटिः 'प्रचालक के लिए कोई मिलान नहीं>' में 'a1> a2' बूल कम बराबर = (a1) हालांकि, यदि एक समान प्रकार-विशिष्ट (यानी। गैर-टेम्पलेट) प्रचालक वर्तमान दायरे में मौजूद है, यहां तक कि वर्ग परिभाषा के बाहर भी, संकलक इसके बजाय इसे पसंद करेगा। //(ऊपर से जारी) #include <उपयोगिता> नेमस्पेस का उपयोग करते हुए एसटीडीः: रिलेऑप्स;// नीचे ऑपरेटर सुपरसीड्स रिलेऑप्स बूल ऑपरेटर> = (कॉन्स्ट ए और ए1, कॉन्स्ट ए और ए2) {डू _ समथिंग _ एल्स ();// कुछ विशिष्ट दुष्प्रभाव रिटर्न करें! (ए1 <ए2);// लेकिन अन्यथा उसी प्रक्रिया का उपयोग करें जैसे कि रिले _ ऑप्स}; शून्य एफ2 (कॉन्स्ट ए और ए1, कॉन्स्ट ए और ए2) {बूल बराबर = (ए1 = = ए2);// ऑपरेटर का उपयोग करता है = = वर्ग ए के भीतर परिभाषित बूल नॉट _ बराबर = (ए1! = ए2);// उपयोग करता है! (a1 = = a2) पर रिलेऑप्स बूल लेस्स = (a1 <a2);// वर्ग A बूल ग्रेटर = (a1> a2) के भीतर परिभाषित ऑपरेटर का उपयोग करता है;// प्रति रिलेऑप्स बूल लेस्स इक्वल = (a1 <= a2) का उपयोग करता है;// उपयोग करता है! (a2 <a1) प्रति रिले _ ऑप्स बूल ग्रेटर _ इक्वल = (a1> = a2);// वैश्विक प्रचालक का उपयोग करता है> = ऊपर परिभाषित किया गया है} कोई भी निश्चित रूप से निम्नलिखित के साथ मिलकर घोषणा कर सकता है, जिससे सभी संबंधपरक प्रचालक की व्युत्पत्ति की अनुमति मिलती हैः टेम्पलेट <क्लास _ टीपी> इनलाइन बूल प्रचालक = = (कॉन्स्ट _ टीपी एंड _ एक्स, कॉन्स्ट _ टीपी एंड _ वाई) {रिटर्न! (_ _ x <_ _ y।। _ _ y <_ x);} जोड़ी घोषित एक वस्तु, उदाहरण के लिए, जिसमें दो सदस्य होंगे, और, साथ में तीन निर्माता कार्य होंगे। पहला (डिफ़ॉल्ट) कंस्ट्रक्टर दोनों सदस्यों को डिफ़ॉल्ट मानों के साथ आरंभ करता है और, जबकि दूसरा प्रत्येक प्रकार के एक पैरामीटर को स्वीकार करता है। तीसरा एक टेम्पलेट प्रतिलिपि-निर्माता है जो किसी भी प्रकार को स्वीकार करेगा, बशर्ते कि प्रकार और क्रमशः अंतर्निहित रूपांतरण में सक्षम हों। जी. सी. सी. का कार्यान्वयन तंत्र को निम्नानुसार परिभाषित करता है। टेम्पलेट <क्लास _ टी1, क्लास _ टी2> संरचना जोड़ी <टाइपडेफ _ टी1 प्रथम प्रकार; टाइपडेफ _ टी2 द्वितीय प्रकार; _ टी1 प्रथम; _ टी2 द्वितीय; जोड़ी (): प्रथम (), द्वितीय () {} जोड़ी (कॉन्स्ट _ टी1 & _ ए, कॉन्स्ट _ टी2 & _ बी): प्रथम (_ ए), द्वितीय (_ बी) {} टेम्पलेट <वर्ग _ यू1, वर्ग _ यू2> जोड़ी (कॉन्स्ट जोड़ी <_ यू1, _ यू2> & _ पी): प्रथम (__p.first), द्वितीय (__p.second) {}); इसके अतिरिक्त यह शीर्षलेख उदाहरणों के लिए सभी छह संबंधपरक प्रचालक को परिभाषित करता है। ये तत्वों के आधार पर प्रकार की वस्तुओं के लिए एक सख्त कमजोर क्रम को परिभाषित करते हैं और फिर केवल तत्वों पर जब वे बराबर होते हैं। //उपरोक्त टेम्पलेट से जारी <क्लास _ टी1, क्लास _ टी2> इनलाइन बूल ऑपरेटर = = (कॉन्स्ट जोड़ी <_ टी1, _ टी2> और _ _ एक्स, कॉन्स्ट जोड़ी <_ टी1, _ टी2> और _ _ वाई) {रिटर्न __x.first = = __y.first और & & __x.second = = __y.second;} टेम्पलेट <क्लास _ टी1, क्लास _ टी2> इनलाइन बूल ऑपरेटर <(कॉन्स्ट जोड़ी <_ टी1, _ टी2> और _ _ एक्स, कॉन्स्ट जोड़ी <_ टी1, _ टी2> और _ _ वाई) {रिटर्न __x.first <__y.first। (! (__y.first <__x.first) & & __x.second <__y.second);} टेम्पलेट <क्लास _ T1, क्लास _ T2> इनलाइन बूल ऑपरेटर! (_ _ x = = _ _ y);} टेम्पलेट <क्लास _ T1, क्लास _ T2> इनलाइन बूल ऑपरेटर> (कॉन्स्ट जोड़ी <_ T1, _ T2> & _ _ x, कॉन्स्ट जोड़ी <_ T1, _ T2> & _ y) {रिटर्न _ y <_ x;} टेम्पलेट <क्लास _ T1, क्लास _ T2> इनलाइन बूल ऑपरेटर <= (कॉन्स्ट जोड़ी <_ T1, _ T2> & _ x, कॉन्स्ट जोड़ी <_ T1, _ T2> & _ y) {रिटर्न! (_ _ y <_ _ x);} टेम्पलेट <क्लास _ T1, क्लास _ T2> इनलाइन बूल ऑपरेटर> = (स्थिरांक जोड़ी <_ T1, _ T2> & _ _ x, स्थिरांक जोड़ी <_ T1, _ T2> & _ _ y) {वापसी! (_ _ x <_ _ y);} इसके अतिरिक्त हेडर में एक टेम्पलेट-फ़ंक्शन होता है जो मापदंडों के आधार पर अपने वापसी प्रकार का अनुमान लगाता हैः// उपरोक्त टेम्पलेट से जारी <वर्ग _ T1, वर्ग _ T2> इनलाइन जोड़ी <_ T1, _ T2> मेक _ पेयर (_ T1 _ x, _ T2 _ y) {वापसी जोड़ी <_ T1, _ T2> (_ _ x, _ _ y);} सामान्य उपयोगिताओं के लिए बाहरी लिंक C + + संदर्भ पुस्तकालय C + + मानक पुस्तकालय