मेन्यू

उदाहरणों में सी ++ में टेम्पलेट

templates c with examples

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

C ++ में टेम्प्लेट के विभिन्न पहलुओं को जानें।

टेम्प्लेट C ++ में सबसे शक्तिशाली विशेषताओं में से एक हैं। टेम्पलेट हमें वह कोड प्रदान करते हैं जो डेटा प्रकार से स्वतंत्र है।

दूसरे शब्दों में, टेम्प्लेट का उपयोग करके, हम एक जेनेरिक कोड लिख सकते हैं जो किसी भी डेटा प्रकार पर काम करता है। हमें बस डेटा टाइप को एक पैरामीटर के रूप में पास करना होगा। यह पैरामीटर जो डेटा प्रकार से गुजरता है, उसे टाइप नाम भी कहा जाता है।

इस ट्यूटोरियल में, हम सभी टेम्पलेट्स और इसके विभिन्न पहलुओं के बारे में विस्तार से जानेंगे।

=> निरपेक्ष सी ++ प्रशिक्षण श्रृंखला के लिए यहां क्लिक करें।

C ++ में टेम्प्लेट

आप क्या सीखेंगे:

टेम्प्लेट क्या हैं?

जैसा कि ऊपर उल्लेख किया गया है, टेम्प्लेट सामान्य हैं यानी डेटा प्रकार से स्वतंत्र हैं। कोड पुनरावृत्ति और कार्यक्रमों के लचीलेपन को सुनिश्चित करने के लिए मुख्य रूप से टेम्पलेट्स का उपयोग किया जाता है। हम केवल एक साधारण फ़ंक्शन या एक वर्ग बना सकते हैं जो डेटा प्रकार को एक पैरामीटर के रूप में लेता है और किसी भी डेटा प्रकार के लिए काम करने वाले कोड को लागू करता है।

उदाहरण के लिए, यदि हम सभी संख्यात्मक डेटा प्रकारों के साथ-साथ वर्ण स्ट्रिंग्स के लिए काम करने के लिए एक सॉर्टिंग एल्गोरिदम चाहते हैं, तो हम सिर्फ एक फ़ंक्शन लिखेंगे जो डेटा प्रकार को एक तर्क के रूप में लेता है और सॉर्टिंग तकनीक को लागू करता है।

फिर डेटा प्रकार (प्रकार का नाम) के आधार पर जो एल्गोरिथ्म को सॉर्ट करने के लिए पारित किया जाता है, हम डेटा प्रकार की परवाह किए बिना डेटा को सॉर्ट कर सकते हैं। इस तरह हमें दस डेटा प्रकारों के लिए दस एल्गोरिदम लिखने की आवश्यकता नहीं है।

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

टेम्पलेट / कार्यान्वयन का उपयोग कैसे करें?

टेम्पलेट दो तरीकों से लागू किए जा सकते हैं:

  • एक फ़ंक्शन टेम्पलेट के रूप में
  • एक वर्ग टेम्पलेट के रूप में

फंक्शन टेम्पलेट

फंक्शन टेम्प्लेट एक सामान्य फंक्शन की तरह है, लेकिन फर्क सिर्फ इतना है कि नॉर्मल फंक्शन केवल एक डेटा टाइप पर काम कर सकता है और एक फंक्शन टेम्प्लेट कोड कई डेटा टाइप्स पर काम कर सकता है।

जबकि हम वास्तव में विभिन्न डेटा प्रकारों पर काम करने के लिए एक सामान्य फ़ंक्शन को अधिभार कर सकते हैं, फ़ंक्शन टेम्प्लेट हमेशा अधिक उपयोगी होते हैं क्योंकि हमें एकमात्र प्रोग्राम लिखना होता है और यह सभी डेटा प्रकारों पर काम कर सकता है।

अगला, हम फ़ंक्शन टेम्प्लेट के कार्यान्वयन को देखेंगे।

फ़ंक्शन टेम्प्लेट का सामान्य सिंटैक्स है:

template T function_name(T args){ …… //function body }

यहाँ, T टेम्प्लेट तर्क है जो विभिन्न डेटा प्रकारों को स्वीकार करता है और क्लास एक कीवर्ड है। कीवर्ड क्लास के बजाय, हम 'टाइपनेम' भी लिख सकते हैं।

जब किसी विशेष डेटा प्रकार को function_name में पास किया जाता है, तो इस फ़ंक्शन की एक प्रतिलिपि इस डेटा प्रकार के साथ कंपाइलर द्वारा एक तर्क और फ़ंक्शन के रूप में निष्पादित की जाती है।

यूनिक्स और लिनक्स समान है

फ़ंक्शन टेम्पलेट को बेहतर ढंग से समझने के लिए एक उदाहरण देखते हैं।

#include using namespace std; template void func_swap(T &arg1, T &arg2) { T temp; temp = arg1; arg1 = arg2; arg2 = temp; } int main() { int num1 = 10, num2 = 20; double d1 = 100.53, d2 = 435.54; char ch1 = 'A', ch2 = 'Z'; cout << 'Original data '; cout << 'num1 = ' << num1 << ' num2 = ' << num2<

मुख्य फ़ंक्शन में, हम टाइप इंट, डबल और चार के डेटा को परिभाषित करते हैं। हम प्रत्येक प्रकार के डेटा के साथ फ़ंक्शन func_swap कहते हैं। फिर हम प्रत्येक डेटा प्रकार के लिए स्वैप किए गए डेटा को प्रदर्शित करते हैं।

इस प्रकार यह दिखाता है कि हमें तीन डेटा प्रकारों के लिए तीन फ़ंक्शन लिखने की आवश्यकता नहीं है। यह केवल एक फ़ंक्शन लिखने के लिए पर्याप्त है और इसे एक टेम्पलेट फ़ंक्शन बनाता है ताकि यह डेटा प्रकार से स्वतंत्र हो।

कक्षा के टेम्पलेट

फ़ंक्शन टेम्प्लेट की तरह, हमारे पास एक वर्ग होने की आवश्यकता हो सकती है जो अन्य सभी पहलुओं के समान हो लेकिन केवल अलग-अलग डेटा प्रकार हो।

इस स्थिति में, हमारे पास अलग-अलग डेटा प्रकारों के लिए अलग-अलग वर्ग हो सकते हैं या एक ही वर्ग में अलग-अलग डेटा प्रकारों के लिए अलग-अलग कार्यान्वयन हो सकते हैं। लेकिन ऐसा करने से हमारा कोड भारी हो जाएगा।

इसके लिए सबसे अच्छा उपाय है कि आप टेम्पलेट क्लास का उपयोग करें। टेम्पलेट क्लास भी फ़ंक्शन टेम्प्लेट के समान व्यवहार करती है। हमें ऑब्जेक्ट बनाते समय या सदस्य फ़ंक्शन को कॉल करते समय क्लास के लिए एक पैरामीटर के रूप में डेटा टाइप पास करना होगा।

वर्ग टेम्पलेट के लिए सामान्य वाक्यविन्यास है:

template class className{ ….. public: T memVar; T memFunction(T args); };

उपरोक्त परिभाषा में, T डेटा प्रकार के लिए प्लेसहोल्डर के रूप में कार्य करता है। सार्वजनिक सदस्यों के मेम्वार और मेमफ़ंक्शन भी डेटा प्रकारों के लिए प्लेसहोल्डर के रूप में टी का उपयोग करते हैं।

एक बार एक टेम्पलेट क्लास को ऊपर के रूप में परिभाषित करने के बाद, हम निम्नानुसार क्लास ऑब्जेक्ट बना सकते हैं:

className classObejct1; className classObject2; className classObject3;

कक्षा टेम्पलेट प्रदर्शित करने के लिए एक कोड उदाहरण लागू करते हैं:

#include using namespace std; template class myclass { T a, b; public: myclass (T first, T second) {a=first; b=second;} T getMaxval (); }; template T myclass::getMaxval () { return (a>b? a : b); } int main () { myclass myobject (100, 75); cout<<'Maximum of 100 and 75 = '<

उपरोक्त कार्यक्रम एक वर्ग टेम्पलेट का एक उदाहरण लागू करता है। हमारे पास टेम्पलेट वर्ग myclass है। इसके अंदर, हमारे पास एक कंस्ट्रक्टर है जो क्लास के दो सदस्यों और बी को इनिशियलाइज़ करेगा। एक अन्य सदस्य फ़ंक्शन getMaxval है जो एक फ़ंक्शन टेम्पलेट भी है जो अधिकतम और बी रिटर्न देता है।

मुख्य कार्य में, हम दो वस्तुओं का निर्माण करते हैं, प्रकार पूर्णांक के myobject और प्रकार चरित्र के mychobject। फिर हम अधिकतम मूल्य निर्धारित करने के लिए इनमें से प्रत्येक ऑब्जेक्ट पर getMaxval फ़ंक्शन को कॉल करते हैं।

ध्यान दें कि टेम्प्लेट टाइप पैरामीटर (टाइप टी के पैरामीटर) के अलावा, टेम्प्लेट फ़ंक्शंस में सामान्य फ़ंक्शंस जैसे सामान्य पैरामीटर और डिफ़ॉल्ट पैरामीटर मान भी हो सकते हैं।

टाइपनेम Vs. क्लास कीवर्ड

टेम्प्लेट क्लास या फ़ंक्शन की घोषणा करते समय, हम दो कीवर्ड क्लास या टाइपनेम में से एक का उपयोग करते हैं। ये दो शब्द शब्दार्थ के समतुल्य हैं और इनका प्रयोग परस्पर किया जा सकता है।

कैसे जावा में वस्तुओं की एक सरणी घोषित करने के लिए

लेकिन कुछ मामलों में, हम इन शब्दों को समकक्ष के रूप में उपयोग नहीं कर सकते हैं। उदाहरण के लिए, जब हम 'टाइप किए गए' जैसे टेम्प्लेट में निर्भर डेटाटाइप का उपयोग कर रहे हैं, तो हम क्लास के बजाय टाइपनेम का उपयोग करते हैं।

इसके अलावा, क्लास कीवर्ड का उपयोग तब किया जाना चाहिए जब हमें किसी टेम्पलेट को तुरंत स्पष्ट करना होगा।

खाका तात्कालिकता और विशेषज्ञता

टेम्प्लेट एक सामान्य तरीके से लिखे गए हैं, जिसका अर्थ है कि यह डेटा प्रकार के बावजूद एक सामान्य कार्यान्वयन है। प्रदान किए गए डेटा प्रकार के अनुसार, हमें प्रत्येक डेटा प्रकार के लिए एक ठोस वर्ग तैयार करना होगा।

उदाहरण के लिए, यदि हमारे पास एक टेम्पलेट सॉर्ट एल्गोरिथ्म है, तो हम सॉर्ट के लिए एक ठोस वर्ग उत्पन्न कर सकते हैं, सॉर्ट के लिए एक अन्य वर्ग, आदि। इसे टेम्प्लेट का तात्कालिकता कहा जाता है।

हम टेम्पलेट वर्ग की परिभाषा में टेम्पलेट मापदंडों के लिए टेम्पलेट तर्क (वास्तविक डेटा प्रकार) को प्रतिस्थापित करते हैं।

उदाहरण के लिए,

template class sort {};

जब हम डेटा टाइप पास करते हैं, तो कंपाइलर डेटा टाइप को so T ’के लिए विकल्प देता है, ताकि सॉर्टिंग एल्गोरिथ्म सॉर्ट हो जाए।

हर बार जब हम टेम्प्लेट क्लास या फ़ंक्शन का उपयोग करते हैं, तो एक उदाहरण की आवश्यकता होती है जब हम किसी विशेष डेटा प्रकार को पास करते हैं। यदि यह उदाहरण पहले से मौजूद नहीं है, तो संकलक विशेष डेटा प्रकार के साथ एक बनाता है। यह निहित तात्कालिकता है।

निहित तात्कालिकता का एक दोष यह है कि कंपाइलर केवल वर्तमान में उपयोग किए जाने वाले तर्कों के लिए उदाहरण वर्ग उत्पन्न करता है। इसका मतलब है कि अगर हम इन उदाहरणों के उपयोग से पहले इंस्टेंस की एक लाइब्रेरी बनाना चाहते हैं, तो हमें स्पष्ट इंस्टेंटेशन के लिए जाना होगा।

टेम्प्लेट घोषणा का एक उदाहरण नीचे दिया गया है:

template class Array(T)

के रूप में स्पष्ट रूप से त्वरित किया जा सकता है:

template class Array

जब एक कक्षा को तत्काल किया जाता है, तो उसके सभी सदस्यों को भी त्वरित किया जाता है।

खाका विशेषज्ञता

टेम्प्लेट का उपयोग करते हुए प्रोग्रामिंग करते समय, हमें एक ऐसी स्थिति का सामना करना पड़ सकता है, जिसमें हमें किसी विशेष डेटा प्रकार के लिए एक विशेष कार्यान्वयन की आवश्यकता हो सकती है। जब ऐसी स्थिति होती है, तो हम टेम्पलेट विशेषज्ञता के लिए जाते हैं।

टेम्प्लेट स्पेशलाइज़ेशन में, हम एक विशेष डेटा प्रकार के लिए एक विशेष व्यवहार को लागू करते हैं, अन्य डेटा प्रकारों के लिए मूल टेम्पलेट परिभाषा के अलावा।

उदाहरण के लिए, विचार करें कि हमारे पास एक टेम्पलेट वर्ग है class मेरी इंक्रीमेंट ' जिसमें एक वैल्यू और एक टेम्प्लेट फंक्शन को इनिशियलाइज़ करने के लिए कंस्ट्रक्टर होता है वेतन वृद्धि मूल्य 1 से बढ़ा है।

यह विशेष वर्ग चार को छोड़कर सभी डेटा प्रकारों के लिए पूरी तरह से काम करेगा। चार के लिए मूल्य बढ़ाने के बजाय, इसे एक विशेष व्यवहार क्यों न दें और इसके बजाय चरित्र को बड़े पैमाने पर परिवर्तित करें?

ऐसा करने के लिए, हम चार डेटा प्रकार के लिए टेम्पलेट विशेषज्ञता के लिए जा सकते हैं।

यह कार्यान्वयन नीचे दिए गए कोड उदाहरण में दिखाया गया है।

#include using namespace std; // class template: template class myIncrement { T value; public: myIncrement (T arg) {value=arg;} T toIncrement () {return ++value;} }; // class template specialization: template class myIncrement { char value; public: myIncrement (char arg) {value=arg;} char uppercase () { if ((value>='a')&&(value<='z')) value+='A'-'a'; return value; } }; int main () { myIncrement myint (7); myIncrement mychar ('s'); myIncrement mydouble(11.0); cout<<'Incremented int value: '<< myint.toIncrement()<< endl; cout<<'Uppercase value: '<

आउटपुट:

बढ़े हुए अंतर मान: 8
अपरकेस मान: एस
बढ़े हुए दोहरे मूल्य: 12

template_specialization

उपरोक्त कार्यक्रम में जो टेम्पलेट विशेषज्ञता को प्रदर्शित करता है, उस तरीके को देखें जिसमें हमने चार प्रकार के लिए एक विशेष टेम्पलेट घोषित किया है। हम पहले मूल वर्ग की घोषणा करते हैं और फिर हम इसे चार प्रकार के लिए 'विशेषज्ञ' करते हैं। विशेषज्ञता शुरू करने के लिए हम खाली टेम्पलेट घोषणा 'टेम्पलेट' का उपयोग करते हैं।

फिर वर्ग नाम के बाद, हम डेटा प्रकार को शामिल करते हैं। इन दो परिवर्तनों के बाद, वर्ग को चार प्रकार के लिए लिखा गया है।

मुख्य कार्य में, ध्यान दें कि चार प्रकार और अन्य प्रकार के तात्कालिकता के बीच कोई अंतर नहीं है। अंतर केवल इतना है कि हम विशेष वर्ग को फिर से परिभाषित करते हैं।

ध्यान दें कि हमें विशेष वर्ग के सभी सदस्यों को परिभाषित करना चाहिए, भले ही वे जेनेरिक / मूल टेम्पलेट वर्ग में बिल्कुल समान हों। इसका कारण यह है कि हमारे पास जेनेरिक टेम्प्लेट से विशेष टेम्प्लेट के सदस्यों के लिए उत्तराधिकार सुविधा नहीं है।

C ++ वैरिएडिक टेम्प्लेट

अब तक हमने फ़ंक्शन टेम्प्लेट देखे हैं जो निश्चित संख्या में तर्क देते हैं। ऐसे भी टेम्प्लेट हैं जो एक चर संख्या में तर्क लेते हैं। इन फ़ंक्शन टेम्प्लेट को वैरेडिक टेम्प्लेट कहा जाता है। वैरिएडिक टेम्प्लेट C ++ 11 की सबसे नई विशेषताओं में से एक हैं।

वेरिएडिक टेम्प्लेट एक प्रकार के तर्कों को लेते हैं जो टाइप-सेफ होते हैं और कंपाइल-टाइम में तर्कों को हल किया जाता है।

आइए इसे समझने के लिए एक संपूर्ण प्रोग्रामिंग उदाहरण लेते हैं।

#include #include using namespace std; template T summation(T val) { return val; } template T summation(T first, Args... args) { return first + summation(args...); } int main() { long sum = summation(1, 2, 3, 8, 7); cout<<'Sum of long numbers = '<

उपर्युक्त उदाहरण वैरिएबल फ़ंक्शन, 'सारांश' प्रदर्शित करता है। जैसा कि ऊपर दिखाया गया है, हमें पहले आधार फ़ंक्शन की आवश्यकता होती है जो आधार मामले को लागू करता है। फिर हम इस फ़ंक्शन के शीर्ष पर वैरेडिक फ़ंक्शन को लागू करते हैं।

चर समारोह योग में, 'टाइपनेम ... आर्ग्स' कहा जाता है टेम्पलेट पैरामीटर पैक जबकि 'आर्ग्स ... आर्ग्स' कहा जाता है समारोह पैरामीटर पैक ।

बेस केस को लागू करने वाले फ़ंक्शन टेम्पलेट को लिखने के बाद, हम एक वैरेडिक फ़ंक्शन लिखते हैं जो सामान्य केस को लागू करता है। वेरिएडिक फ़ंक्शन रिकर्स के समान लिखा जाता है जैसा कि समन के लिए दिखाया गया है (args…)। पहला तर्क फ़ंक्शन पैरामीटर पैक से टाइप T (पहले) में अलग किया गया है।

हर कॉल के लिए समन के साथ, पैरामीटर सूची एक तर्क से संकीर्ण हो जाती है और अंततः आधार स्थिति तक पहुंच जाती है। आउटपुट लंबे पूर्णांक और वर्णों के योग को दर्शाता है।

निष्कर्ष

इसके साथ, हम C ++ में टेम्पलेट्स पर इस ट्यूटोरियल को समाप्त करते हैं। टेम्प्लेट्स हमारे कार्यक्रमों को सामान्य बनाने में हमारी मदद करते हैं यानी प्रकार से स्वतंत्र।

यह भी पढ़ें = >> फ्लास्क टेम्पलेट ट्यूटोरियल

कैसे .jar फ़ाइल को स्थापित करने के लिए

जेनेरिक प्रोग्राम हमेशा अन्य प्रोग्राम्स में सबसे ऊपर खड़े होते हैं क्योंकि हमें प्रत्येक डेटा प्रकार के लिए अलग प्रोग्राम लिखने की आवश्यकता नहीं होती है। इस प्रकार जेनेरिक टाइप-सेफ प्रोग्राम विकसित करना कुशल प्रोग्रामिंग की दिशा में एक महत्वपूर्ण कदम हो सकता है।

=> यहाँ गहराई सी ++ प्रशिक्षण ट्यूटोरियल की जाँच करें।

अनुशंसित पाठ

^