सिंगलटन पैटर्न का उपयोग आमतौर पर तब किया जाता है जब आपको एक एकल, साझा संसाधन की आवश्यकता होती है जिसे विश्व स्तर पर एक्सेस किया जाना चाहिए जैसे कि डेटाबेस कनेक्शन, लॉगर या कॉन्फ़िगरेशन प्रबंधक। एकल उदाहरण को लागू करके, यह प्रोग्राम के कई हिस्सों को एक ही ऑब्जेक्ट तक पहुंचने और संशोधित करने की अनुमति देता है, डेटा स्थिरता को बढ़ावा देता है और वैश्विक चर की आवश्यकता को कम करता है। सिंगलटन को एक ऑब्जेक्ट कैश के रूप में नियोजित किया जा सकता है जहां अक्सर उपयोग की जाने वाली या बनाने में महंगी वस्तुओं को संग्रहीत किया जाता है और पूरे एप्लिकेशन में पुन: उपयोग किया जाता है। यह दृष्टिकोण अनावश्यक ऑब्जेक्ट निर्माण और आरंभीकरण से बचकर प्रदर्शन को बेहतर बनाने में मदद करता है।
इस लेख में, हम सिंगलटन के निर्माण की व्याख्या करेंगे और C++ प्रोग्राम में सिंगलटन को स्टाइल करने का एक उदाहरण प्रदर्शित करेंगे।
उदाहरण 1: उत्सुक आरंभीकरण के साथ एक सरल सिंगलटन बनाना
प्रारंभिक आरंभीकरण के साथ एक सरल सिंगलटन एक डिज़ाइन पैटर्न है जो यह सुनिश्चित करता है कि एक वर्ग का केवल एक उदाहरण बनाया गया है, और इसे स्थैतिक आरंभीकरण के दौरान उत्सुकता से बनाया गया है।
हम उत्सुक आरंभीकरण के साथ एक सरल सिंगलटन के निर्माण के लिए मूल कोड स्निपेट प्रदर्शित करेंगे। आइए कार्यक्रम से शुरुआत करें:
#शामिल करें
क्लास सिंगलटन {
निजी :
स्थिर एकाकी वस्तु * उदाहरण ;
एकाकी वस्तु ( ) { }
जनता :
स्थिर एकाकी वस्तु * दृष्टांत लो ( ) {
वापस करना उदाहरण ;
}
} ;
एकाकी वस्तु * एकाकी वस्तु :: उदाहरण = नया सिंगलटन ( ) ;
int यहाँ मुख्य ( ) {
एकाकी वस्तु * सिंगलटनइंस्टेंस1 = एकाकी वस्तु :: दृष्टांत लो ( ) ;
एकाकी वस्तु * सिंगलटनइंस्टेंस2 = एकाकी वस्तु :: दृष्टांत लो ( ) ;
कक्षा :: अदालत << 'singletonletonInstance1:' << सिंगलटनइंस्टेंस1 << कक्षा :: अंतः ;
कक्षा :: अदालत << 'singletonletonInstance2:' << सिंगलटनइंस्टेंस2 << कक्षा :: अंतः ;
वापस करना 0 ;
}
कोड में
हेडर फ़ाइल को शामिल करने के बाद, हम 'सिंगलटन' वर्ग को परिभाषित करते हैं जो सिंगलटन पैटर्न कार्यान्वयन का प्रतिनिधित्व करता है। इसमें एक निजी कंस्ट्रक्टर और एक निजी स्थिर सदस्य वैरिएबल है जिसका नाम 'इंस्टेंस' है।
फिर, getInstance() फ़ंक्शन को 'सिंगलटन' वर्ग के सार्वजनिक स्थैतिक सदस्य फ़ंक्शन के रूप में कार्यान्वित किया जाता है। यह सिंगलटन का उदाहरण लौटाता है जो स्थिर सदस्य चर उदाहरण में संग्रहीत होता है। स्थिर सदस्य चर उदाहरण को 'सिंगलटन* सिंगलटन::इंस्टेंस = नया सिंगलटन();' के साथ कक्षा के बाहर परिभाषित और आरंभ किया गया है। यह पंक्ति स्थैतिक आरंभीकरण के दौरान उत्सुकता से 'सिंगलटन' वर्ग के उदाहरण को आरंभ करती है।
मुख्य() फ़ंक्शन में, हम दो पॉइंटर्स, 'सिंगलटनइंस्टेंस1' और 'सिंगलटनइंस्टेंस2' घोषित करते हैं, और सिंगलटन::गेटइंस्टेंस() को कॉल करके लौटाए गए मान को असाइन करते हैं। चूंकि उदाहरण उत्सुकता से प्रारंभ किया गया है, दोनों संकेतक एक ही उदाहरण की ओर इशारा करते हैं। 'std::cout' स्टेटमेंट '<<' ऑपरेटर और 'std::endl' का उपयोग करके कंसोल पर 'singletonInstance1' और 'singletonInstance2' के मेमोरी एड्रेस को प्रिंट करते हैं।
कोड 'रिटर्न 0' के साथ समाप्त होता है जो एक सफल प्रोग्राम निष्पादन को इंगित करता है।
जब आप यह कोड चलाते हैं, तो आउटपुट कुछ इस तरह होता है:
आउटपुट 'singletonInstance1' और 'singletonInstance2' के मेमोरी पते प्रदर्शित करता है। चूँकि दोनों पॉइंटर्स को एक ही इंस्टेंस के साथ असाइन किया गया है जो Singleton::getInstance() से प्राप्त किया गया है, उनका मेमोरी एड्रेस एक ही है। यह दर्शाता है कि सिंगलटन पैटर्न कैसे गारंटी देता है कि क्लास का एक ही उदाहरण है और भविष्य में getInstance() पर कॉल का परिणाम हमेशा एक ही उदाहरण होगा।
उदाहरण 2: आलसी आरंभीकरण के साथ सिंगलटन पैटर्न कार्यान्वयन
यह प्रदर्शन आलसी आरंभीकरण के साथ सिंगलटन पैटर्न कार्यान्वयन की व्याख्या करता है और मुख्य() फ़ंक्शन में इसका उपयोग दिखाता है। इस प्रोग्राम के बाद कोड स्निपेट की चरण-दर-चरण व्याख्या प्रदान की गई है:
#शामिलक्लास सिंगलटन {
निजी :
स्थिर एकाकी वस्तु * उदाहरण ;
एकाकी वस्तु ( ) {
कक्षा :: अदालत << 'सिंगलटन उदाहरण बनाया गया।' << कक्षा :: अंतः ;
}
जनता :
स्थिर एकाकी वस्तु * दृष्टांत लो ( ) {
अगर ( उदाहरण == nullptr ) {
उदाहरण = नया सिंगलटन ( ) ;
}
वापस करना उदाहरण ;
}
खालीपन संदेश दिखाएँ ( ) {
कक्षा :: अदालत << 'सिंगलटन की ओर से नमस्ते!' << कक्षा :: अंतः ;
}
~सिंगलटन ( ) {
कक्षा :: अदालत << 'सिंगलटन उदाहरण नष्ट हो गया।' << कक्षा :: अंतः ;
}
} ;
एकाकी वस्तु * एकाकी वस्तु :: उदाहरण = nullptr ;
int यहाँ मुख्य ( ) {
एकाकी वस्तु * सिंगलटनइंस्टेंस1 = एकाकी वस्तु :: दृष्टांत लो ( ) ;
सिंगलटनइंस्टेंस1 -> संदेश दिखाएँ ( ) ;
एकाकी वस्तु * सिंगलटनइंस्टेंस2 = एकाकी वस्तु :: दृष्टांत लो ( ) ;
सिंगलटनइंस्टेंस2 -> संदेश दिखाएँ ( ) ;
वापस करना 0 ;
}
प्रोग्राम इनपुट/आउटपुट कार्यों को पूरा करने के लिए
जब भी 'सिंगलटन' क्लास के कंस्ट्रक्टर को कॉल किया जाता है, तो यह 'सिंगलटन' क्लास का एक उदाहरण उत्पन्न करता है। यह 'std::cout << … << std::endl;' का उपयोग करके कंसोल पर 'सिंगलटन इंस्टेंस निर्मित' संदेश आउटपुट करता है। कंस्ट्रक्टर के पास कोई पैरामीटर नहीं है क्योंकि यह एक डिफ़ॉल्ट कंस्ट्रक्टर है। इसे बिना किसी तर्क के सिंगलटन() के रूप में परिभाषित किया गया है। हम इसे निजी घोषित करते हैं जिसका अर्थ है कि इसे केवल कक्षा के अंदर से ही लागू किया जा सकता है। यह 'सिंगलटन' वर्ग के सीधे इंस्टेंटेशन को रोकता है और यह सुनिश्चित करता है कि इंस्टेंस प्राप्त करने का एकमात्र तरीका getInstance() फ़ंक्शन के माध्यम से है।
'सिंगलटन' वर्ग की getInstance() विधि को सार्वजनिक स्थैतिक सदस्य फ़ंक्शन के रूप में घोषित किया गया है। यह सिंगलटन उदाहरण को स्थापित करने और पहुंच प्रदान करने की भूमिका में है। GetInstance() के अंदर, यह जाँचता है कि क्या इंस्टेंस 'nullptr' है। यदि ऐसा है, तो यह दर्शाता है कि उदाहरण पहले से मौजूद नहीं है, यह 'सिंगलटन' वर्ग की एक नई वस्तु को इंस्टेंट करने के लिए निजी कंस्ट्रक्टर का उपयोग करता है।
शोमैसेज() फ़ंक्शन एक साधारण सदस्य फ़ंक्शन है जो 'सिंगलटन से हैलो!' प्रदर्शित करता है। संदेश। सिंगलटन के विध्वंसक को परिभाषित किया गया है। इसे अंतर्निहित रूप से तब कहा जाता है जब प्रोग्राम समाप्त हो जाता है और 'सिंगलटन इंस्टेंस नष्ट हो गया' प्रिंट करता है। संदेश जो इंगित करता है कि सिंगलटन उदाहरण नष्ट हो गया है। स्थैतिक सदस्य चर उदाहरण को प्रारंभ में 'nullptr' के रूप में परिभाषित किया गया है।
Int main() मुख्य() फ़ंक्शन की परिभाषा शुरू करता है। फिर, 'सिंगलटन* सिंगलटनइंस्टेंस1 = सिंगलटन::गेटइंस्टेंस();' सिंगलटन इंस्टेंस के लिए पॉइंटर प्राप्त करने के लिए 'सिंगलटन' क्लास के getInstance() फ़ंक्शन को कॉल करता है। यह इस पॉइंटर को 'singletonInstance1' वेरिएबल को असाइन करता है।
उसके बाद, 'singletonInstance1->showMessage();' 'singletonInstance1' पॉइंटर पर showMessage() फ़ंक्शन को कॉल करने के लिए एरो ऑपरेटर (->) का उपयोग करता है। यह फ़ंक्शन इसमें निर्दिष्ट संदेश को कंसोल पर प्रदर्शित करता है। बाद में, 'सिंगलटन* सिंगलटनइंस्टेंस2 = सिंगलटन::गेटइंस्टेंस();' सिंगलटन इंस्टेंस के लिए एक और पॉइंटर प्राप्त करते हुए, getInstance() फ़ंक्शन को फिर से कॉल करता है। इस बार, यह पॉइंटर को 'singletonInstance2' वेरिएबल को असाइन करता है। “singletonInstance2->showMessage();” 'singletonInstance2' पॉइंटर पर showMessage() फ़ंक्शन को कॉल करता है। यह फ़ंक्शन 'सिंगलटन की ओर से नमस्ते!' प्रदर्शित करता है। कंसोल पर फिर से संदेश।
अंत में, 'वापसी 0;' मुख्य() फ़ंक्शन के अंत को दर्शाता है, और प्रोग्राम 0 का मान लौटाता है जो एक सफल प्रोग्राम निष्पादन को दर्शाता है।
यहां पहले बताए गए कोड स्निपेट का आउटपुट दिया गया है:
यह परिणाम पुष्टि करता है कि 'सिंगलटन' वर्ग केवल एक उदाहरण के निर्माण का आश्वासन देता है और getInstance() फ़ंक्शन पर आगे कॉल करने से विश्वसनीय रूप से वही उदाहरण मिलता है।
निष्कर्ष
C++ में सिंगलटन बनाना एक बहुत ही उपयोगी अवधारणा है। इस पोस्ट में, हमने शुरुआत में सिंगलटन के परिचय अनुभाग को कवर किया। इसके अलावा, C++ में सिंगलटन को लागू करने के लिए दो उदाहरण तैयार किए गए हैं। पहला चित्रण उत्सुक सिंगलटन आरंभीकरण के कार्यान्वयन को दर्शाता है। जबकि सिंगलटन पैटर्न का आलसी आरंभीकरण कार्यान्वयन इस आलेख के दूसरे उदाहरण में प्रदान किया गया है। इसके अलावा, उत्पादित आउटपुट के स्नैपशॉट भी संबंधित प्रोग्राम के लिए प्रदर्शित किए जाते हैं।