C++ प्रोग्रामिंग सबसे अच्छी भाषा है क्योंकि यह हमें फ़ंक्शंस, कंस्ट्रक्टर्स, हेडर फ़ाइलों, कक्षाओं और बहुत कुछ की एक विस्तृत श्रृंखला की सुविधा प्रदान करती है, जिससे कोडिंग अधिक रोचक और आसान हो जाती है। C++ प्रोग्रामिंग में कंस्ट्रक्टरों में से एक 'मूव' कंस्ट्रक्टर है। 'मूव' कंस्ट्रक्टर एक अद्वितीय प्रकार का कंस्ट्रक्टर है जो गतिशील रूप से आवंटित मेमोरी या अन्य संसाधनों के स्वामित्व को प्रभावी और संसाधन-सचेत तरीके से एक ऑब्जेक्ट से दूसरे में स्थानांतरित करने की अनुमति देता है।
C++ प्रोग्रामिंग में, दोहराव को कम करने और दक्षता बढ़ाने के लिए 'मूव' कंस्ट्रक्टर पेश किए गए थे। यह प्रतिलिपि संचालन को कम करके प्रदर्शन को बेहतर बनाने में महत्वपूर्ण भूमिका निभाता है। यह मार्गदर्शिका C++ प्रोग्रामिंग में 'मूव' कंस्ट्रक्टर के बारे में गहराई से खोज करती है।
उदाहरण 1:
यहां कोड शुरू करने के लिए, हम 'iostream' और 'स्ट्रिंग' हेडर फ़ाइलें शामिल करते हैं जो हमारे कोड को पूरी तरह से चलाएंगे क्योंकि इन हेडर फ़ाइलों में कई फ़ंक्शन घोषित किए गए हैं। जब हमें 'काउट' स्टेटमेंट का उपयोग करना होता है, तो 'iostream' हेडर फ़ाइल का उपयोग किया जाता है क्योंकि यह फ़ंक्शन इसके अंदर घोषित किया गया है। जब हमें स्ट्रिंग प्रकार के डेटा के साथ काम करना होता है, तो 'स्ट्रिंग' हेडर फ़ाइल आवश्यक होती है।
इसके बाद, इन हेडर फ़ाइलों के नीचे 'नेमस्पेस एसटीडी' जोड़ा जाता है। फिर, हम यहां एक क्लास बनाते हैं। क्लास का नाम 'मूव' है। इसके नीचे, 'निजी' कीवर्ड जोड़ा गया है जिसमें हम 'my_str' नाम के साथ एक निजी स्ट्रिंग वेरिएबल घोषित करते हैं। अब, हम 'सार्वजनिक' कीवर्ड डालते हैं जहां हम डिफ़ॉल्ट कंस्ट्रक्टर की परिभाषा जोड़ते हैं। हम पैरामीटर के रूप में 'यह यहां डिफ़ॉल्ट स्ट्रिंग है' को 'my_str' में पास करते हैं और डिफ़ॉल्ट कंस्ट्रक्टर को खाली छोड़ देते हैं।
इसके बाद, हम कंस्ट्रक्टर परिभाषा को कॉपी करते हैं और 'my_str' को 'my_obj.my_str' में इनिशियलाइज़ करते हैं। इसके नीचे, हम एक लाइन प्रिंट करते हैं और फिर 'मूव' कंस्ट्रक्टर की परिभाषा डालते हैं। यहां, हम 'my_str' को फिर से 'my_obj.my_str' से आरंभ करते हैं। हम इसके नीचे कोई कथन नहीं जोड़ते हैं; यह खाली है। इसके बाद, हम स्ट्रिंग प्रकार का 'displayMyObject()' नामक एक फ़ंक्शन घोषित करते हैं और 'रिटर्न स्ट्र' का उपयोग करते हैं ताकि यह स्ट्रिंग लौटा सके।
हम वैश्विक 'new_temp' फ़ंक्शन को 'मूव' प्रकार में रखते हैं। इसके नीचे, हमारे पास 'रिटर्न टेम्प' है जो मूव टाइप ऑब्जेक्ट लौटाता है। अब, हम 'मुख्य()' ड्राइवर कोड और 'मूव' प्रकार का 'new_obj1' डालते हैं और 'रिवैल्यू' से 'मूव' कंस्ट्रक्टर प्राप्त करते हैं। आगे की पंक्ति में, हम 'लवैल्यू' से 'मूव' कंस्ट्रक्टर प्राप्त करने के लिए 'new_obj1.displayMyObject()' रखते हैं। इसके बाद, हम 'move' कंस्ट्रक्टर को 'my_obj1' ऑब्जेक्ट के साथ कॉल करते हैं। फिर, हम 'my_obj1' का स्वामित्व दूसरे ऑब्जेक्ट में स्थानांतरित कर देते हैं जो कि 'my_obj2' है।
कोड 1:
#शामिल करें#शामिल <स्ट्रिंग>
का उपयोग करते हुए नाम स्थान कक्षा ;
कक्षा कदम
{
निजी :
स्ट्रिंग my_str ;
जनता :
कदम ( ) : my_str ( 'यह यहाँ डिफ़ॉल्ट स्ट्रिंग है' )
{
}
कदम ( कॉन्स्ट कदम & my_obj ) : my_str ( my_obj. my_str )
{
अदालत << 'कॉपी कंस्ट्रक्टर लागू किया गया, मूव विफल रहा! \एन ' ;
}
कदम ( कदम && my_obj ) : my_str ( कदम ( my_obj. my_str ) )
{
}
स्ट्रिंग डिस्प्लेमायऑब्जेक्ट ( )
{
वापस करना my_str ;
}
} ;
new_temp ले जाएँ ( टीएमपी ले जाएँ )
{
वापस करना टीएमपी ;
}
int यहाँ मुख्य ( )
{
new_obj1 ले जाएँ = new_temp ( कदम ( ) ) ;
अदालत << 'स्थानांतरित करने से पहले() कॉल करें: new_obj1 = ' << new_obj1. मेराऑब्जेक्ट प्रदर्शित करें ( ) << अंतः ;
new_obj2 ले जाएँ = कदम ( new_obj1 ) ;
अदालत << 'आफ्टर मूव() कंस्ट्रक्टर कॉल: new_obj1= ' << new_obj1. मेराऑब्जेक्ट प्रदर्शित करें ( ) << अंतः ;
अदालत << 'मूव() कंस्ट्रक्टर कॉल के बाद: new_obj2 = ' << new_obj2. मेराऑब्जेक्ट प्रदर्शित करें ( ) << अंतः ;
वापस करना 0 ;
}
आउटपुट:
आउटपुट प्रस्तुत करता है कि 'मूव()' विधि को कॉल करने से पहले, 'new_obj1' में डिफ़ॉल्ट स्ट्रिंग होती है। लेकिन 'मूव' क्लास मूव() विधि को कॉल करने के बाद, 'my_obj1' में एक खाली स्ट्रिंग होती है और 'my_obj2' में डिफ़ॉल्ट स्ट्रिंग होती है।
उदाहरण 2:
यहां, हम एक और हेडर फ़ाइल शामिल करते हैं जो 'वेक्टर' हेडर फ़ाइल है। जब भी हमें वैक्टर पर संचालन में हेरफेर करना होता है तो हम इसे शामिल करते हैं। जो वर्ग हम यहां बनाते हैं वह 'मूव' वर्ग है। हम यहां एक 'पब्लिक' कंस्ट्रक्टर भी बनाते हैं जिसमें हम 'int* वैल्यू' रॉ पॉइंटर को क्लास मेंबर का डेटा घोषित करते हैं। इसके नीचे, हमारे पास 'पब्लिक' है जिसमें हम 'मूव' कंस्ट्रक्टर रखते हैं और इसके पैरामीटर के रूप में 'int v1' पास करते हैं।
इसके बाद, हम वस्तुओं को ढेर में घोषित करते हैं। हम 'वैल्यू' को 'न्यू इंट' से और '*वैल्यू' को 'v1' से इनिशियलाइज़ करते हैं। फिर, 'काउट' रखें जहां हम एक लाइन जोड़ते हैं जो कोड निष्पादित करते समय प्रिंट होती है। इसके नीचे, हम 'कॉपी' कंस्ट्रक्टर का उपयोग करते हैं। यह 'कॉपी' कंस्ट्रक्टर डीप कॉपी बनाकर डेटा को कॉपी करता है। हम 'मूव' कंस्ट्रक्टर रखते हैं और 'मूव&& न्यू_सोर्स' को इसके पैरामीटर के रूप में पास करते हैं। इसके नीचे, हम 'काउट' रखते हैं जो आवश्यक कथन प्रदर्शित करने में सहायता करता है।
हम यह निर्धारित करने के लिए 'nullptr' कीवर्ड डालते हैं कि संदर्भ का उपयोग करने से पहले कोई पॉइंटर खाली है या नहीं। अब, हम '~मूव()' डिस्ट्रक्टर भी रखते हैं जिसमें हम 'if' कंडीशन रखते हैं जो सत्यापित करता है कि 'वैल्यू' 'nullptr' के बराबर नहीं है। जब यह शर्त सत्यापित हो जाती है, तो इसके नीचे दिया गया कथन निष्पादित हो जाता है। यदि यह स्थिति सत्यापित नहीं है, तो यह 'काउट' कथन को छोड़ देती है जो 'यदि' स्थिति के बाद मौजूद होता है और 'अन्य' भाग की ओर चला जाता है।
इसके बाद, हम 'डिलीट' कीवर्ड का उपयोग करते हैं जो किसी ऑब्जेक्ट को डी-लोकेट करने में सहायता करता है या हम कह सकते हैं कि यह ऑब्जेक्ट के डेटा घटक को आवंटित मेमोरी को रिलीज़ करता है। अब, हम यहां 'मुख्य()' विधि लागू करते हैं और 'my_vec' नाम के साथ अपने 'मूव' वर्ग का वेक्टर बनाते हैं। इसके बाद, हम 'push_back()' फ़ंक्शन का उपयोग करते हैं जो वेक्टर के समापन बिंदु पर एक मान डालने में मदद करता है। 'वेक्टर' हेडर फ़ाइल में यह फ़ंक्शन शामिल है। सबसे पहले, हम वेक्टर में '39' डालते हैं। फिर, '57' डाला जाता है और 'पुश_बैक()' विधि का उपयोग करके '91' भी डाला जाता है।
कोड 2:
#शामिल करें#शामिल <वेक्टर>
का उपयोग करते हुए नाम स्थान कक्षा ;
कक्षा कदम {
निजी :
int यहाँ * कीमत ;
जनता :
कदम ( int यहाँ v1 )
{
कीमत = नया int यहाँ ;
* कीमत = v1 ;
अदालत << 'कंस्ट्रक्टर को बुलाया गया है'
<< v1 << अंतः ;
} ;
कदम ( कॉन्स्ट कदम & नए स्रोत )
: कदम { * नए स्रोत। कीमत }
{
अदालत << 'कॉपी कंस्ट्रक्टर को कहा जाता है -'
<< 'के लिए डीप कॉपी'
<< * नए स्रोत। कीमत
<< अंतः ;
}
कदम ( कदम && नए स्रोत )
: कीमत { नए स्रोत। कीमत }
{
अदालत << 'कंस्ट्रक्टर को इसके लिए ले जाएँ'
<< * नए स्रोत। कीमत << अंतः ;
नए स्रोत। कीमत = nullptr ;
}
~हटो ( )
{
अगर ( कीमत ! = nullptr )
अदालत << 'विनाशक को बुलाया जाता है'
<< * कीमत << अंतः ;
अन्य
अदालत << 'विनाशक कहा जाता है'
<< 'nullptr के लिए'
<< अंतः ;
मिटाना कीमत ;
}
} ;
int यहाँ मुख्य ( )
{
वेक्टर < कदम > मेरी चीज ;
मेरी चीज। वापस धक्का देना ( कदम { 39 } ) ;
मेरी चीज। वापस धक्का देना ( कदम { 57 } ) ;
मेरी चीज। वापस धक्का देना ( कदम { 91 } ) ;
वापस करना 0 ;
}
आउटपुट:
इससे पता चलता है कि 'कॉपी' फ़ंक्शन का उपयोग करने के बजाय, हमें 'कॉपी' फ़ंक्शन पर अनावश्यक कॉल को रोकने के लिए 'मूव' फ़ंक्शन का उपयोग करना होगा। 'मूव' कंस्ट्रक्टर को यहां तब लागू किया जाता है जब हम ऑब्जेक्ट को किसी अस्थायी ऑब्जेक्ट या किसी ऑब्जेक्ट के साथ प्रारंभ करते हैं जो नष्ट हो जाएगा। दिए गए डेटा की गहरी प्रतिलिपि में हेरफेर करने के बजाय, 'मूव' कंस्ट्रक्टर संसाधनों के स्वामित्व को एक ऑब्जेक्ट से दूसरे ऑब्जेक्ट में स्थानांतरित कर देता है।
निष्कर्ष
इस गाइड में, हमने 'मूव' कंस्ट्रक्टर के बारे में पता लगाया। हमने समझाया कि C++ प्रोग्रामिंग में 'मूव' कंस्ट्रक्टर किसी ऑब्जेक्ट के संसाधनों को किसी अन्य ऑब्जेक्ट में प्रभावी ढंग से स्थानांतरित करने का एक अनूठा तरीका है। हमने चर्चा की कि 'मूव' कंस्ट्रक्टर को कॉल करने पर ओवरहेड कम होता है, जिससे कोड अधिक मेमोरी-कुशल हो जाता है। हमने इस तथ्य का पता लगाया कि C++ प्रोग्रामिंग में 'मूव' कंस्ट्रक्टर एक शक्तिशाली विशेषता है। हमने 'मूव' कंस्ट्रक्टर की अवधारणा को समझाने के लिए व्यावहारिक उदाहरणों का भी उपयोग किया और C++ प्रोग्रामिंग में 'मूव' कंस्ट्रक्टर के उपयोग के प्रदर्शन लाभों का प्रदर्शन किया।