RBSE Solutions Class 12 Computer Science Chapter 10 कंस्ट्रक्टर और डिस्ट्रक्टर

RBSE Class 12 Computer Science Chapter 10 पाठ्यपुस्तक के प्रश्न

RBSE Class 12 Computer Science Chapter 10 वस्तुनिष्ठ प्रश्न

Question 1. इनमें से कौनसा कंस्ट्रक्टरस के संदर्भ में सत्य है?
(अ) इसका नाम क्लास के नाम जैसा ही होता है।
(ब) ये क्लास के पब्लिक अनुभाग में घोषित होने चाहिए।
(स) जब ऑब्जेक्ट घोषित किये जाते हैं तब ये स्वतः ही कॉल हो जाते हैं।
(द) उपरोक्त सभी
Answer: (द) उपरोक्त सभी
In simple words: कंस्ट्रक्टरस का नाम हमेशा क्लास के नाम जैसा ही होता है, उन्हें पब्लिक सेक्शन में डिक्लेयर किया जाता है, और वे ऑब्जेक्ट बनते ही अपने आप चल पड़ते हैं। यह कंस्ट्रक्टर की मुख्य पहचान है।

🎯 Exam Tip: कंस्ट्रक्टर की सभी प्रमुख विशेषताओं को याद रखें, क्योंकि यह C++ के ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOP) का एक महत्वपूर्ण हिस्सा है।

Question 3. कंस्ट्रक्टर जो एक ऑब्जेक्ट को उसी क्लास के दूसरे ऑब्जेक्ट से घोषित और इनिशियलाइज करता है, उसे कहा जाता है
(अ) डिफ़ॉल्ट कंस्ट्रक्टर
(ब) कॉपी कंस्ट्रक्टर
(स) पैरामीटराइज्ड कंस्ट्रक्टर
(द) इनमें से कोई नहीं
Answer: (ब) कॉपी कंस्ट्रक्टर
In simple words: जब एक ऑब्जेक्ट की कॉपी बनाकर दूसरा ऑब्जेक्ट बनाया जाता है, तो इस प्रक्रिया को कॉपी कंस्ट्रक्टर संभालता है। यह नया ऑब्जेक्ट पुराने ऑब्जेक्ट के डेटा को कॉपी करता है।

🎯 Exam Tip: कॉपी कंस्ट्रक्टर अक्सर तब उपयोग होता है जब आप ऑब्जेक्ट्स को फंक्शन्स में पास करते हैं या उन्हें वापस लौटाते हैं।

Question 4. इनमें से कौनसा डिस्ट्रक्टरस के संदर्भ में सत्य है?
(अ) इसका नाम क्लास के नाम के जैसा होता है। लेकिन इसके नाम से पहले tilde (~) चिह्न होता है।
(ब) यह आरग्यूमेन्ट नहीं लेता है और वेल्यू भी रिटर्न नहीं करता है।
(स) यह कम्पाइलर के द्वारा स्वतः ही कॉल होता है जब किसी प्रोग्राम या ब्लॉक या फंक्शन से बाहर आते हैं।
(द) उपरोक्त सभी
Answer: (द) उपरोक्त सभी
In simple words: डिस्ट्रक्टर का नाम क्लास के समान होता है, पर उसके पहले 'tilde' (~) चिन्ह होता है। यह कोई इनपुट नहीं लेता और कुछ भी वापस नहीं करता। जब कोई ऑब्जेक्ट प्रोग्राम से बाहर निकलता है, तो यह अपने आप ही काम करता है।

🎯 Exam Tip: डिस्ट्रक्टर मेमोरी मैनेजमेंट के लिए बहुत महत्वपूर्ण है, खासकर जब आपने कंस्ट्रक्टर में डायनामिक मेमोरी आवंटित की हो।

RBSE Class 12 Computer Science Chapter 10 अतिलघु उत्तरीय प्रश्न

Question 1. कंस्ट्रक्टरस क्या होते हैं?
Answer: कंस्ट्रक्टरस क्लास के विशेष प्रकार के मेम्बर फंक्शन होते हैं। इनका मुख्य काम क्लास के ऑब्जेक्ट्स को बनाने के बाद उन्हें शुरुआती मान (initialize) देना होता है। कंस्ट्रक्टर का नाम हमेशा उसी क्लास के नाम जैसा होता है जिसमें उसे बनाया गया है।
In simple words: कंस्ट्रक्टर क्लास के खास फंक्शन होते हैं। ये ऑब्जेक्ट बनने पर उसे शुरू करते हैं और उनका नाम क्लास के जैसा ही होता है।

🎯 Exam Tip: कंस्ट्रक्टर ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में ऑब्जेक्ट के सही ढंग से शुरू होने के लिए आवश्यक हैं।

Question 2. पैरामीटराइज्ड कंस्ट्रक्टरस क्या होते हैं?
Answer: ऐसे कंस्ट्रक्टरस जो ऑब्जेक्ट बनाते समय कोई इनपुट (आरग्यूमेन्ट) लेते हैं, उन्हें पैरामीटराइज्ड कंस्ट्रक्टरस कहा जाता है। ऑब्जेक्ट बनाते समय, हम इन कंस्ट्रक्टरस को वैल्यूज पास कर सकते हैं। ये वैल्यूज फिर क्लास के वेरिएबल को दिए जा सकते हैं ताकि ऑब्जेक्ट को विशेष मानों के साथ शुरू किया जा सके।
In simple words: जो कंस्ट्रक्टर ऑब्जेक्ट बनाते समय कुछ इनपुट लेते हैं, उन्हें पैरामीटराइज्ड कंस्ट्रक्टर कहते हैं। इससे ऑब्जेक्ट को अपनी पसंद के मान दिए जा सकते हैं।

🎯 Exam Tip: पैरामीटराइज्ड कंस्ट्रक्टर तब उपयोगी होते हैं जब आप हर ऑब्जेक्ट को अलग-अलग शुरुआती मान देना चाहते हैं।

Question 1. कंस्ट्रक्टर की क्या विशेषताएँ होती हैं?
Answer: कंस्ट्रक्टर की मुख्य विशेषताएँ इस प्रकार हैं:
• इसका नाम हमेशा क्लास के नाम जैसा ही होता है।
• इसे क्लास के पब्लिक सेक्शन में घोषित किया जाना चाहिए।
• जब कोई ऑब्जेक्ट बनाया जाता है, तो यह अपने आप ही चल पड़ता है।
• इसका कोई रिटर्न टाइप नहीं होता है, 'void' भी नहीं, और यह कोई वैल्यू वापस नहीं करता है। यह एक महत्वपूर्ण अंतर है।
• इसे इनहेरिट नहीं किया जा सकता है।
• इसके एड्रेस को सीधे एक्सेस नहीं किया जा सकता है।
In simple words: कंस्ट्रक्टर का नाम क्लास जैसा होता है, यह पब्लिक होता है, अपने आप चलता है, कुछ वापस नहीं करता और इनहेरिट नहीं होता। इसका एड्रेस सीधे नहीं ले सकते।

🎯 Exam Tip: कंस्ट्रक्टर की ये विशेषताएँ C++ में ऑब्जेक्ट के जीवन चक्र (lifecycle) और मेमोरी प्रबंधन को समझने के लिए महत्वपूर्ण हैं।

Question 2. डिस्ट्रक्टरस क्या होते हैं? इनकी विशेषताएँ लिखो।
Answer: डिस्ट्रक्टर क्लास का एक विशेष प्रकार का मेम्बर फंक्शन होता है, जिसका उपयोग कंस्ट्रक्टर के द्वारा बनाए गए ऑब्जेक्ट को खत्म करने के लिए किया जाता है। डिस्ट्रक्टर ऑब्जेक्ट द्वारा ली गई मेमोरी को खाली करने में मदद करता है। डिस्ट्रक्टर फंक्शन की निम्नलिखित विशेषताएँ होती हैं:
• इसका नाम क्लास के नाम के जैसा होता है, लेकिन इसके नाम से पहले 'tilde' (~) चिह्न लगा होता है।
• यह कोई आरग्यूमेन्ट नहीं लेता है और कोई वैल्यू रिटर्न नहीं करता है।
• जब किसी प्रोग्राम या कोड ब्लॉक या फंक्शन से ऑब्जेक्ट बाहर आता है, तब यह कम्पाइलर के द्वारा अपने आप कॉल होता है।
In simple words: डिस्ट्रक्टर ऑब्जेक्ट खत्म करने का फंक्शन है। इसका नाम क्लास जैसा होता है पर पहले ~ लगता है। ये इनपुट नहीं लेते, कुछ वापस नहीं करते, और ऑब्जेक्ट खत्म होने पर अपने आप चलते हैं।

🎯 Exam Tip: डिस्ट्रक्टर का उपयोग डायनामिक रूप से आवंटित मेमोरी को मुक्त करने और रिसोर्स को सही ढंग से रिलीज करने के लिए करें।

Question 3. डिस्ट्रक्टरस के उपयोग लिखो।
Answer: डिस्ट्रक्टर का मुख्य उपयोग रन टाइम पर ऑब्जेक्ट द्वारा ली गई मेमोरी को मुक्त करना है। इससे यह सुनिश्चित होता है कि खाली हुई मेमोरी का उपयोग दूसरे प्रोग्राम या ऑब्जेक्ट्स के लिए किया जा सके। जब कंस्ट्रक्टर फंक्शन में `new` ऑपरेटर का उपयोग करके किसी ऑब्जेक्ट के लिए मेमोरी आवंटित की जाती है, तो डिस्ट्रक्टर फंक्शन में `delete` ऑपरेटर का उपयोग करके उसी मेमोरी को फिर से सिस्टम को वापस दिया जाता है।
In simple words: डिस्ट्रक्टर ऑब्जेक्ट द्वारा ली गई मेमोरी को खाली करने के लिए होते हैं। ये `new` से ली गई मेमोरी को `delete` करके वापस देते हैं, ताकि कंप्यूटर की मेमोरी अच्छे से इस्तेमाल हो सके।

🎯 Exam Tip: मेमोरी लीकेज से बचने के लिए, हमेशा कंस्ट्रक्टर में आवंटित की गई हर डायनामिक मेमोरी को डिस्ट्रक्टर में `delete` करना याद रखें।

RBSE Class 12 Computer Science Chapter 10 निबंधात्मक प्रश्न

Question 1. डिफॉल्ट आरग्यूमेन्ट के साथ कंस्ट्रक्टर का वर्णन कीजिए।
Answer: डिफॉल्ट आरग्यूमेन्ट वाले कंस्ट्रक्टर वे होते हैं, जिनमें कुछ या सभी आरग्यूमेन्ट के लिए पहले से ही मान (डिफॉल्ट वैल्यू) दिए होते हैं। यदि हम कंस्ट्रक्टर को कॉल करते समय उन आरग्यूमेन्ट के लिए कोई मान नहीं देते, तो वे अपने डिफॉल्ट मान का उपयोग करते हैं। डिफॉल्ट आरग्यूमेन्ट हमेशा दायें से बायें दिए जाते हैं। उदाहरण के लिए:
`point (int a, int b=0);`
यहाँ, आरग्यूमेन्ट `b` की डिफॉल्ट वैल्यू `शून्य` है।
यदि हम `point (5);` लिखते हैं, तो यह `a` को 5 वैल्यू देता है और `b` को डिफॉल्ट वैल्यू शून्य देता है।
यदि हम `point(7, 11);` लिखते हैं, तो `a` को 7 और `b` को 11 वैल्यू मिलती है, क्योंकि जब वास्तविक पैरामीटर दिए जाते हैं तो वे डिफॉल्ट आरग्यूमेन्ट को ओवरराइड कर देते हैं।
यदि एक ही नाम के साथ एक आरग्यूमेन्ट वाला कंस्ट्रक्टर भी मौजूद है (जैसे `point (int a);`), तो `point (5);` कॉल करने पर कम्पाइलर को यह तय करने में मुश्किल होगी कि किस कंस्ट्रक्टर को कॉल किया जाए। इससे 'अस्पष्टता' की स्थिति उत्पन्न होती है और कम्पाइलर एक त्रुटि संदेश देता है। यह सुनिश्चित करना महत्वपूर्ण है कि ऐसे ओवरलोड कंस्ट्रक्टर अस्पष्टता पैदा न करें।
In simple words: डिफॉल्ट आरग्यूमेन्ट वाले कंस्ट्रक्टर में, कुछ इनपुट के लिए पहले से ही मान तय होते हैं। अगर हम कॉल करते समय कोई मान नहीं देते, तो वे पहले से तय मान का उपयोग करते हैं। अगर हम मान देते हैं, तो वह पहले से तय मान को बदल देता है।

🎯 Exam Tip: डिफॉल्ट आरग्यूमेन्ट का उपयोग करके आप एक ही कंस्ट्रक्टर को कई अलग-अलग तरीकों से कॉल कर सकते हैं, जिससे कोड कम और अधिक लचीला हो जाता है। अस्पष्टता से बचने के लिए कंस्ट्रक्टर ओवरलोडिंग के नियमों को ध्यान में रखें।

RBSE Class 12 Computer Science Chapter 10 अन्य महत्त्वपूर्ण प्रश्न

RBSE Class 12 Computer Science Chapter 10 अतिलघु उत्तरीय प्रश्न

Question 1. कंस्ट्रक्टर का रिटर्न टाईप क्या होता है?
Answer: कंस्ट्रक्टर का कोई रिटर्न टाइप नहीं होता है। यहाँ तक कि 'void' भी नहीं होता है, क्योंकि कंस्ट्रक्टर का मुख्य काम ऑब्जेक्ट को इनिशियलाइज करना है, न कि कोई वैल्यू वापस लौटाना। यह ऑब्जेक्ट की शुरुआती अवस्था को सेट करता है।
In simple words: कंस्ट्रक्टर कोई भी वैल्यू वापस नहीं देता है, 'void' भी नहीं। इसका काम सिर्फ ऑब्जेक्ट को शुरू करना है।

🎯 Exam Tip: यह एक महत्वपूर्ण नियम है, क्योंकि कंस्ट्रक्टर को फ़ंक्शन के रूप में समझने की गलती से बचा जा सकता है जो कोई मान लौटाता है।

Question 2. क्या कंस्ट्रक्टर को इनहेरिट किया जा सकता है?
Answer: नहीं, कंस्ट्रक्टर को इनहेरिट नहीं किया जा सकता है। चाइल्ड क्लास अपने पेरेंट क्लास के कंस्ट्रक्टर को सीधे तौर पर इनहेरिट नहीं करती है। हालांकि, चाइल्ड क्लास अपने कंस्ट्रक्टर में पेरेंट क्लास के कंस्ट्रक्टर को कॉल कर सकती है।
In simple words: नहीं, कंस्ट्रक्टर को सीधे दूसरी क्लास में नहीं ले जाया जा सकता।

🎯 Exam Tip: चाइल्ड क्लास को पेरेंट कंस्ट्रक्टर को स्पष्ट रूप से कॉल करना होता है, यह इनहेरिटेंस में एक खास व्यवहार है।

Question 3. डिफॉल्ट कंस्ट्रक्टर किसे कहते हैं?
Answer: जो कंस्ट्रक्टर कोई भी इनपुट (आरग्यूमेन्ट) नहीं लेता है, उसे डिफॉल्ट कंस्ट्रक्टर कहा जाता है। यदि आप क्लास में कोई कंस्ट्रक्टर नहीं बनाते हैं, तो कम्पाइलर अपने आप एक डिफॉल्ट कंस्ट्रक्टर बना देता है।
In simple words: वह कंस्ट्रक्टर जो कोई इनपुट नहीं लेता, डिफॉल्ट कंस्ट्रक्टर कहलाता है।

🎯 Exam Tip: यदि आप क्लास में कोई अन्य कंस्ट्रक्टर परिभाषित करते हैं, तो कम्पाइलर अपने आप डिफॉल्ट कंस्ट्रक्टर नहीं बनाएगा, इसलिए आपको उसे खुद बनाना होगा यदि उसकी आवश्यकता हो।

Question 4. पैरामीटराइज्ड कंस्ट्रक्टर को कितने तरीकों से कॉल किया जा सकता है?
Answer: पैरामीटराइज्ड कंस्ट्रक्टर को दो तरीकों से कॉल किया जा सकता है: एक्सप्लिसिट कॉल (explicit call) और इम्प्लिसिट कॉल (implicit call)। एक्सप्लिसिट कॉल में हम कंस्ट्रक्टर को एक फंक्शन की तरह स्पष्ट रूप से बुलाते हैं, जैसे `point p = point (10, 20);`। इम्प्लिसिट कॉल में हम ऑब्जेक्ट को सीधे मानों के साथ बनाते हैं, और कंस्ट्रक्टर अपने आप कॉल हो जाता है, जैसे `point p (10, 20);`। दोनों तरीके एक ही काम करते हैं, बस लिखने का तरीका अलग होता है।
In simple words: पैरामीटराइज्ड कंस्ट्रक्टर को दो तरह से बुला सकते हैं: सीधा नाम लेकर (explicit) या ऑब्जेक्ट बनाते हुए मान देकर (implicit)।

🎯 Exam Tip: एक्सप्लिसिट और इम्प्लिसिट कॉल के बीच का अंतर केवल सिंटैक्स में है, लेकिन दोनों ऑब्जेक्ट को सफलतापूर्वक इनिशियलाइज करते हैं।

Question 6. क्या एक कंस्ट्रक्टर अपनी क्लास का रेफरेंस एक ऑरग्यूमेन्ट के रूप में ले सकता है?
Answer: हाँ, एक कंस्ट्रक्टर अपनी क्लास का रेफरेंस एक आरग्यूमेन्ट के रूप में ले सकता है। इस तरह के कंस्ट्रक्टर को कॉपी कंस्ट्रक्टर कहा जाता है, जिसका उपयोग एक ऑब्जेक्ट के डेटा को दूसरे ऑब्जेक्ट में कॉपी करने के लिए किया जाता है। यह ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में एक महत्वपूर्ण विशेषता है।
In simple words: हाँ, एक कंस्ट्रक्टर अपनी क्लास का रेफरेंस इनपुट के रूप में ले सकता है। इसे कॉपी कंस्ट्रक्टर कहते हैं।

🎯 Exam Tip: कॉपी कंस्ट्रक्टर का उपयोग तब करें जब आप ऑब्जेक्ट को बाय वैल्यू पास कर रहे हों या उसे किसी फंक्शन से लौटा रहे हों।

Question 7. डाइनामिक इनिशियलाइजेशन क्या होता है?
Answer: एक ऑब्जेक्ट की शुरुआती वैल्यूज (मान) को प्रोग्राम के चलने के समय (रन टाइम पर) देना ही डाइनामिक इनिशियलाइजेशन कहलाता है। सामान्य इनिशियलाइजेशन में मान पहले से तय होते हैं, लेकिन डाइनामिक में हम यूजर इनपुट या किसी गणना के आधार पर मान दे सकते हैं।
In simple words: ऑब्जेक्ट को रन टाइम पर मान देना डाइनामिक इनिशियलाइजेशन कहलाता है।

🎯 Exam Tip: डाइनामिक इनिशियलाइजेशन प्रोग्राम को अधिक लचीला बनाता है क्योंकि शुरुआती मान प्रोग्राम चलने के दौरान तय किए जा सकते हैं।

Question 8. डाइनामिक इनिशियलाइजेशन का क्या फायदा है?
Answer: डाइनामिक इनिशियलाइजेशन का फायदा यह है कि हम विभिन्न प्रकार के इनपुट के साथ कंस्ट्रक्टर ओवरलोडिंग का उपयोग कर सकते हैं। यह हमें एक ही कंस्ट्रक्टर नाम का उपयोग करके अलग-अलग डेटा टाइप्स या अलग-अलग संख्या में आरग्यूमेन्ट के साथ ऑब्जेक्ट बनाने की सुविधा देता है। इससे कोड अधिक अनुकूलनीय और पुन: प्रयोज्य हो जाता है।
In simple words: इसका फायदा यह है कि हम कई तरह के इनपुट के साथ कंस्ट्रक्टर ओवरलोडिंग का इस्तेमाल कर सकते हैं।

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

Question 9. कॉपी कंस्ट्रक्टर से आप क्या समझते हो?
Answer: कॉपी कंस्ट्रक्टर एक विशेष प्रकार का कंस्ट्रक्टर है जो एक ऑब्जेक्ट को उसी क्लास के किसी दूसरे ऑब्जेक्ट का उपयोग करके घोषित और इनिशियलाइज करता है। दूसरे शब्दों में, यह एक मौजूदा ऑब्जेक्ट की एक नई कॉपी बनाने के लिए उपयोग होता है। एक कॉपी कंस्ट्रक्टर उसी क्लास के ऑब्जेक्ट का रेफरेंस आरग्यूमेन्ट के रूप में लेता है।
In simple words: कॉपी कंस्ट्रक्टर एक ऑब्जेक्ट की कॉपी से नया ऑब्जेक्ट बनाता है। यह इनपुट में उसी क्लास के दूसरे ऑब्जेक्ट का रेफरेंस लेता है।

🎯 Exam Tip: कॉपी कंस्ट्रक्टर `(const ClassName &obj)` इस प्रारूप में लिखे जाते हैं, जहाँ `const` ऑब्जेक्ट को गलती से बदलने से रोकता है।

Question 10. डिस्ट्रक्टर की एक विशेषता बताइए।
Answer: डिस्ट्रक्टर की एक प्रमुख विशेषता यह है कि इसका नाम क्लास के नाम जैसा ही होता है, लेकिन इसके नाम से पहले 'tilde' (~) चिह्न लगा होता है। यह `~` चिन्ह कम्पाइलर को बताता है कि यह एक डिस्ट्रक्टर है। उदाहरण के लिए, यदि क्लास का नाम `MyClass` है, तो डिस्ट्रक्टर का नाम `~MyClass` होगा।
In simple words: डिस्ट्रक्टर का नाम क्लास के समान होता है, पर उसके आगे 'tilde' (~) चिन्ह लगता है।

🎯 Exam Tip: डिस्ट्रक्टर की यह नामकरण प्रथा इसे कंस्ट्रक्टर और अन्य मेम्बर फंक्शन्स से अलग पहचान देती है।

Question 11. डिस्ट्रक्टर फंक्शन में आवंटित मैमोरी को पुनः वापिस कैसे लिया जाता है?
Answer: डिस्ट्रक्टर फंक्शन में डायनामिक रूप से आवंटित मेमोरी को `delete` ऑपरेटर का उपयोग करके पुनः सिस्टम को वापस लिया जाता है। यदि कंस्ट्रक्टर में `new` ऑपरेटर से मेमोरी ली गई है, तो उस मेमोरी को मुक्त करने के लिए डिस्ट्रक्टर में `delete` का उपयोग करना अनिवार्य है। ऐसा करने से मेमोरी लीकेज नहीं होता और प्रोग्राम सही ढंग से चलता है।
In simple words: डिस्ट्रक्टर में `delete` ऑपरेटर का उपयोग करके, `new` से ली गई मेमोरी को वापस लिया जाता है।

🎯 Exam Tip: `new` और `delete` का सही युग्मन मेमोरी मैनेजमेंट में त्रुटियों को रोकने के लिए महत्वपूर्ण है।

Question 2. पैरामीटराइज्ड कंस्ट्रक्टर को उदाहरण सहित समझाइए।
Answer: पैरामीटराइज्ड कंस्ट्रक्टर वह कंस्ट्रक्टर होता है जो ऑब्जेक्ट बनाते समय आरग्यूमेन्ट (इनपुट) लेता है। ये आरग्यूमेन्ट ऑब्जेक्ट के मेम्बर वेरिएबल्स को शुरुआती मान देने के लिए उपयोग किए जाते हैं।
उदाहरण के लिए, `point` नामक क्लास में एक पैरामीटराइज्ड कंस्ट्रक्टर बनाया गया है जो दो पूर्णांक (integers) `a` और `b` को आरग्यूमेन्ट के रूप में लेता है:
`class point`
`{`
` int x, y;`
`public:`
` point (int a, int b) //parameterized constructor`
` {`
` x=a;`
` y=b;`
` }`
`};`
पैरामीटराइज्ड कंस्ट्रक्टर को दो तरीकों से कॉल किया जा सकता है:
1. एक्सप्लिसिट कॉल (Explicit Call): इस तरीके में कंस्ट्रक्टर को सीधे फंक्शन कॉल की तरह लिखा जाता है।
`point p = point (10, 20); //explicit call`
यह स्टेटमेंट एक ऑब्जेक्ट `p` को 10 और 20 वैल्यू से इनिशियलाइज करता है।
2. इम्प्लिसिट कॉल (Implicit Call): इस तरीके में कंस्ट्रक्टर को ऑब्जेक्ट डिक्लेरेशन के साथ ही मान पास किए जाते हैं।
`point p (10, 20); //implicit call`
यह स्टेटमेंट एक्सप्लिसिट कॉल की तरह ही काम करता है।
In simple words: पैरामीटराइज्ड कंस्ट्रक्टर वो होता है जो ऑब्जेक्ट बनते समय इनपुट लेता है। इससे ऑब्जेक्ट के अंदर के वेरिएबल को मान दिए जाते हैं। इसे दो तरह से बुला सकते हैं: सीधे फंक्शन की तरह या ऑब्जेक्ट बनाते समय।

🎯 Exam Tip: उदाहरण में कोड और उसकी व्याख्या दोनों को सही ढंग से लिखें, यह दिखाएगा कि आप पैरामीटराइज्ड कंस्ट्रक्टर के कामकाज को समझते हैं।

Question 3. कंस्ट्रक्टर फंक्शन को इनलाईन फंक्शन के रूप में परिभाषित करने का एक उदाहरण दीजिए। अथवा इनलाईन फंक्शन का एक प्रोग्राम लिखिए।
Answer: कंस्ट्रक्टर फंक्शन को इनलाइन फंक्शन के रूप में भी परिभाषित किया जा सकता है। जब एक फंक्शन को `inline` कीवर्ड के साथ परिभाषित किया जाता है, तो कम्पाइलर फंक्शन कॉल की जगह सीधे फंक्शन के कोड को डाल देता है। इससे फंक्शन कॉल का ओवरहेड (extra processing) बच जाता है।
उदाहरण के लिए, एक `point` क्लास का इनलाइन कंस्ट्रक्टर:
`class point`
`{`
` int x,y;`
`public:`
` inline point (int a, int b) // Inline constructor`
` {`
` x=a;`
` y=b;`
` }`
`};`
कंस्ट्रक्टर के आरग्यूमेन्ट किसी भी टाइप के हो सकते हैं सिवाय उस क्लास के जिससे ये सम्बन्धित हैं (यानी, क्लास टाइप रेफरेंस या पॉइंटर हो सकता है)।
In simple words: कंस्ट्रक्टर को `inline` कीवर्ड के साथ भी बना सकते हैं। ऐसा करने से, जब कंस्ट्रक्टर को बुलाया जाता है, तो उसका कोड सीधे वहीं डाल दिया जाता है, जिससे प्रोग्राम तेजी से चलता है।

🎯 Exam Tip: छोटे और बार-बार कॉल होने वाले फंक्शन्स के लिए इनलाइन उपयुक्त है, लेकिन बड़े फंक्शन्स को इनलाइन करने से कोड का आकार बढ़ सकता है।

Question 5. डिस्ट्रक्टर के उपयोग से मैमोरी को मुक्त करने के लिए प्रोग्राम लिखिए।
Answer: डिस्ट्रक्टर का मुख्य उपयोग डायनामिक रूप से आवंटित मेमोरी को मुक्त करना है ताकि मेमोरी लीकेज से बचा जा सके। यहाँ एक प्रोग्राम का उदाहरण दिया गया है जो डिस्ट्रक्टर का उपयोग करके डायनामिक मेमोरी को मुक्त करता है। इस उदाहरण में, `sample` क्लास का कंस्ट्रक्टर ऑब्जेक्ट बनने पर 'Object created' प्रिंट करता है, और डिस्ट्रक्टर ऑब्जेक्ट खत्म होने पर 'Object destroyed' प्रिंट करता है:
`#include`
`using namespace std;`
`class sample`
`{`
`public:`
` sample () // Constructor`
` {`
` cout<<"Object created\n";`
` }`
` ~sample () //Destructor`
` {`
` cout<< "Object destroyed\n";`
` }`
`};`
`int main ()`
`{`
` sample s;`
` return 0;`
`}`
**प्रोग्राम का आउटपुट होगा:**
`Object created`
`Object destroyed`

मेमोरी डी-एलोकेशन के लिए विस्तृत प्रोग्राम:
`#include`
`using namespace std;`
`class sample`
`{`
` char *t;`
`public:`
` sample (int len)`
` {`
` t = new char[len+1];`
` cout << "Character array of length " << len << " created\n";`
` }`
` ~sample ()`
` {`
` delete [] t;`
` cout<<"\nMemory de-allocated for the character array";`
` }`
`};`
`int main()`
`{`
` sample s (10);`
` return 0;`
`}`
**प्रोग्राम का आउटपुट होगा:**
`Character array of length 10 created`
`Memory de-allocated for the character array`
In simple words: डिस्ट्रक्टर मेमोरी को खाली करने के लिए होते हैं। यह प्रोग्राम दिखाता है कि जब ऑब्जेक्ट बनता है तो मेमोरी ली जाती है और जब ऑब्जेक्ट खत्म होता है तो डिस्ट्रक्टर उस मेमोरी को `delete` करके वापस कर देता है।

🎯 Exam Tip: `new` के साथ ली गई हर मेमोरी को `delete` करना सुनिश्चित करें, और `new[]` के साथ ली गई मेमोरी को `delete[]` के साथ ही मुक्त करें ताकि मेमोरी लीकेज न हो।

RBSE Class 12 Computer Science Chapter 10 निबंधात्मक प्रश्न

Question 1. पैरामीटराइज्ड कंस्ट्रक्टर की सहायता से एक आयत (rectangle) का क्षेत्रफल (area) ज्ञात करने का प्रोग्राम (program) लिखिए।
Answer: यहाँ एक C++ प्रोग्राम है जो पैरामीटराइज्ड कंस्ट्रक्टर का उपयोग करके एक आयत का क्षेत्रफल ज्ञात करता है। `rectangle` क्लास के कंस्ट्रक्टर में लंबाई और चौड़ाई को आरग्यूमेन्ट के रूप में पास किया जाता है।
`#include`
`using namespace std;`
`class rectangle`
`{`
` int length;`
` int breadth;`
`public:`
` // Parameterized constructor`
` rectangle (int a, int b)`
` {`
` length=a;`
` breadth=b;`
` }`
` // Function to calculate and display area`
` int calculateArea()`
` {`
` return length * breadth;`
` }`
`};`
`int main ()`
`{`
` // Creating an object 'r' and initializing it with length 5 and breadth 10`
` rectangle r (5,10);`
` cout << "Area= " << r.calculateArea() << endl;`
` return 0;`
`}`
**प्रोग्राम का आउटपुट होगा:**
`Area= 50`
In simple words: यह प्रोग्राम एक `rectangle` क्लास बनाता है। जब आप `rectangle` ऑब्जेक्ट बनाते हैं, तो लंबाई और चौड़ाई के मान तुरंत दिए जाते हैं। फिर, यह ऑब्जेक्ट अपने आप आयत का क्षेत्रफल गिनकर बताता है।

🎯 Exam Tip: पैरामीटराइज्ड कंस्ट्रक्टर ऑब्जेक्ट्स को तुरंत सही मानों के साथ इनिशियलाइज करने के लिए बहुत उपयोगी होते हैं, जिससे कोड साफ और त्रुटि-मुक्त रहता है।

Question 2. कंस्ट्रक्टर ओवरलोडिंग से आप क्या समझते हैं? एक प्रोग्राम द्वारा स्पष्ट कीजिए। अथवा बिना आरग्यूमेन्ट का कंस्ट्रक्टर (no argument constructor), एक आरग्यूमेन्ट का कंस्ट्रक्टर (one argument constructor) और दो आरग्यूमेन्ट का कंस्ट्रक्टर (two argument constructor) को एक प्रोग्राम द्वारा समझाइए।
Answer: कंस्ट्रक्टर ओवरलोडिंग का मतलब है कि एक क्लास में एक से ज्यादा कंस्ट्रक्टर हो सकते हैं, बशर्ते उनके पैरामीटर लिस्ट (आरग्यूमेन्ट की संख्या या प्रकार) अलग-अलग हों। यह हमें एक ही क्लास के ऑब्जेक्ट को अलग-अलग तरीकों से इनिशियलाइज करने की सुविधा देता है।
यहाँ एक प्रोग्राम है जो कंस्ट्रक्टर ओवरलोडिंग को समझाता है:
`#include`
`using namespace std;`
`class point`
`{`
` int x,y;`
`public:`
` // No argument constructor (Default Constructor)`
` point ()`
` {`
` x=0;`
` y=0;`
` }`
` // One argument constructor`
` point (int a)`
` {`
` x=y=a;`
` }`
` // Two arguments constructor`
` point (int m, int n)`
` {`
` x=m;`
` y=n;`
` }`
` // Function to display coordinates`
` void show ()`
` {`
` cout<<"x="<` cout<<"y="<` }`
`};`
`int main()`
`{`
` point p1; // Calls no argument constructor (x=0, y=0)`
` point p2 (5); // Calls one argument constructor (x=5, y=5)`
` point p3 (7,11); // Calls two arguments constructor (x=7, y=11)`
` cout<<"Coordinates of p1 are\n";`
` p1. show ();`
` cout<<"Coordinates of p2 are\n";`
` p2. show ();`
` cout<<"Coordinates of p3 are\n";`
` p3. show ();`
` return 0;`
`}`
**प्रोग्राम का आउटपुट होगा:**
`Coordinates of p1 are`
`x=0`
`y=0`
`Coordinates of p2 are`
`x=5`
`y=5`
`Coordinates of p3 are`
`x=7`
`y=11`
उपरोक्त प्रोग्राम में, `point` क्लास में तीन कंस्ट्रक्टर हैं। पहला कंस्ट्रक्टर बिना आरग्यूमेन्ट का है, जो ऑब्जेक्ट को शून्य मानों (x=0, y=0) से शुरू करता है। दूसरा कंस्ट्रक्टर एक आरग्यूमेन्ट लेता है और उस मान को x और y दोनों को देता है। तीसरा कंस्ट्रक्टर दो आरग्यूमेन्ट लेता है और उन्हें x तथा y को अलग-अलग मानों के रूप में असाइन करता है। इससे हम एक ही क्लास के ऑब्जेक्ट को अलग-अलग तरीकों से बना और इनिशियलाइज कर सकते हैं।
In simple words: कंस्ट्रक्टर ओवरलोडिंग का मतलब है एक ही क्लास में कई कंस्ट्रक्टर बनाना, बस उनके इनपुट अलग-अलग होने चाहिए। इससे हम ऑब्जेक्ट को कई तरह से शुरू कर सकते हैं, जैसे कोई इनपुट न देकर, एक इनपुट देकर या दो इनपुट देकर।

🎯 Exam Tip: कंस्ट्रक्टर ओवरलोडिंग का सही उपयोग कोड की पुनरावृत्ति (repetition) को कम करता है और क्लास को अधिक लचीला बनाता है। पैरामीटरों की संख्या और प्रकार को अलग रखकर अस्पष्टता से बचें।

Question 3. ऑब्जेक्ट के डाइनामिक इनिशियलाइजेशन को एक प्रोग्राम द्वारा समझाइए।
Answer: ऑब्जेक्ट के डाइनामिक इनिशियलाइजेशन का अर्थ है कि ऑब्जेक्ट को उसकी शुरुआती वैल्यूज रन टाइम पर (प्रोग्राम के चलने के दौरान) दी जाती हैं, न कि कंपाइल टाइम पर। यह प्रोग्राम को अधिक लचीला बनाता है क्योंकि मान यूजर इनपुट या प्रोग्राम की शर्तों के आधार पर सेट किए जा सकते हैं।
यहाँ एक C++ प्रोग्राम है जो `shape` क्लास के ऑब्जेक्ट के डाइनामिक इनिशियलाइजेशन को दर्शाता है:
`#include`
`using namespace std;`
`class shape`
`{`
` float length, breadth;`
` float radius;`
` float area;`
`public:`
` shape () { } // Default constructor`
` // Constructor for circle`
` shape (float r)`
` {`
` radius=r;`
` area=3.14* r* r;`
` }`
` // Constructor for rectangle`
` shape (float l, float b)`
` {`
` length=l;`
` breadth=b;`
` area=length*breadth;`
` }`
` void displayArea ()`
` {`
` cout<<"Area="<` }`
`};`
`int main()`
`{`
` shape circle, rectangle;`
` float r, l, b;`
` cout<<"Enter the radius of circle\n";`
` cin>>r;`
` circle=shape (r); // Dynamic initialization for circle`
` cout<<"Enter the length and breadth of rectangle\n";`
` cin>>l>>b;`
` rectangle=shape(l, b); // Dynamic initialization for rectangle`
` cout << "Area of circle\n";`
` circle.displayArea();`
` cout << "Area of rectangle\n";`
` rectangle.displayArea();`
` return 0;`
`}`
**प्रोग्राम का आउटपुट होगा:**
`Enter the radius of circle`
`5`
`Enter the length and breadth of rectangle`
`17`
`8`
`Area of circle`
`78.5`
`Area of rectangle`
`136`
In simple words: डाइनामिक इनिशियलाइजेशन तब होता है जब ऑब्जेक्ट को उसका शुरुआती मान प्रोग्राम के चलते समय यूजर से मिलता है। इस प्रोग्राम में, हम सर्कल और आयत के लिए उनकी त्रिज्या, लंबाई और चौड़ाई रन टाइम पर लेते हैं और कंस्ट्रक्टर उन मानों का उपयोग करके ऑब्जेक्ट बनाते हैं।

🎯 Exam Tip: डाइनामिक इनिशियलाइजेशन विशेष रूप से तब उपयोगी होता है जब ऑब्जेक्ट के शुरुआती मानों का निर्णय प्रोग्राम के बाहरी इनपुट या अन्य रनटाइम गणनाओं पर निर्भर करता है।

Question 4. कॉपी कंस्ट्रक्टर को उदाहरण सहित समझाइए।
Answer: कॉपी कंस्ट्रक्टर एक विशेष प्रकार का कंस्ट्रक्टर है जिसका उपयोग एक क्लास के ऑब्जेक्ट को उसी क्लास के किसी दूसरे ऑब्जेक्ट से इनिशियलाइज करने के लिए किया जाता है। यह एक ऑब्जेक्ट की कॉपी बनाकर नया ऑब्जेक्ट बनाता है। एक कॉपी कंस्ट्रक्टर अपनी क्लास के ऑब्जेक्ट का रेफरेंस आरग्यूमेन्ट के रूप में लेता है।
यहाँ एक प्रोग्राम का उदाहरण दिया गया है जो कॉपी कंस्ट्रक्टर का उपयोग करता है:
`#include`
`using namespace std;`
`class product`
`{`
` int code;`
`public:`
` product () { } //default constructor`
` product (int x) //parameterized constructor`
` {`
` code=x;`
` }`
` product (product &y) //copy constructor`
` {`
` code=y.code; //copy the value`
` }`
` void display()`
` {`
` cout << code;`
` }`
`};`
`int main()`
`{`
` product p1(10); // Parameterized constructor called`
` product p2 (p1); // Copy constructor called (using explicit call syntax)`
` product p3=p1; // Copy constructor called (using implicit assignment syntax)`
` cout<<"Code of p1:";`
` p1.display();`
` cout<<"\n Code of p2:";`
` p2.display();`
` cout<<"\n Code of p3:";`
` p3.display();`
` return 0;`
`}`
**प्रोग्राम का आउटपुट होगा:**
`Code of p1:10`
`Code of p2:10`
`Code of p3:10`
In simple words: कॉपी कंस्ट्रक्टर एक ऑब्जेक्ट की तरह ही दूसरा ऑब्जेक्ट बनाने के लिए होता है। इस प्रोग्राम में, `p1` ऑब्जेक्ट `10` के साथ बनता है, फिर `p2` और `p3` ऑब्जेक्ट `p1` की कॉपी करके बनाए जाते हैं, इसलिए `p2` और `p3` का कोड भी `10` हो जाता है।

🎯 Exam Tip: जब आप ऑब्जेक्ट को बाय वैल्यू पास करते हैं, किसी फंक्शन से ऑब्जेक्ट लौटाते हैं, या एक ऑब्जेक्ट को दूसरे से इनिशियलाइज करते हैं, तो कॉपी कंस्ट्रक्टर अपने आप कॉल होता है। डीप कॉपी और शैलो कॉपी के बीच के अंतर को समझना महत्वपूर्ण है।