RBSE Solutions Class 12 Computer Science Chapter 11 ऑपरेटर ओवरलोडिंग

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

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

Question 1. किस ऑपरेटर को ओवरलोड किया जा सकता है?
(अ) स्कोप रिजोल्यूशन ऑपरेटर (::)
(ब) क्लास मेंम्बर एक्सेस ऑपरेटर (., .*)
(स) बाइनरी प्लस ऑपरेटर (+)
(द) कंडिशनल ऑपरेटर (?:)
Answer: (स) बाइनरी प्लस ऑपरेटर (+)
In simple words: बाइनरी प्लस ऑपरेटर (+) को हम अपनी ज़रूरत के हिसाब से बदल सकते हैं, ताकि यह अलग-अलग डेटा टाइप के लिए अलग-अलग काम कर सके.

🎯 Exam Tip: याद रखें कि सभी ऑपरेटरों को ओवरलोड नहीं किया जा सकता है; कुछ ऑपरेटरों पर यह सुविधा लागू नहीं होती है.

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

🎯 Exam Tip: बाइनरी ऑपरेटरों को ओवरलोड करते समय, मेम्बर फ़ंक्शन और फ़्रेंड फ़ंक्शन के आरग्यूमेन्ट की संख्या में अंतर को ध्यान में रखें.

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

🎯 Exam Tip: यूनरी ऑपरेटर वे होते हैं जो सिर्फ़ एक चीज़ पर काम करते हैं, जैसे कि किसी संख्या को प्लस या माइनस करना.

Question 4. किस ऑपरेटर को फ्रेंड फंक्शन से ओवरलोड नहीं कर सकते हैं?
(अ) = असाइनमेंट ऑपरेटर
(ब) () फंक्शन कॉल ऑपरेटर
(स) [] सबस्क्रिप्टिंग ऑपरेटर
(द) ये सभी
Answer: (द) ये सभी
In simple words: कुछ खास ऑपरेटर ऐसे होते हैं जिन्हें आप फ़्रेंड फंक्शन का इस्तेमाल करके ओवरलोड नहीं कर सकते. इनमें असाइनमेंट, फ़ंक्शन कॉल और सबस्क्रिप्टिंग ऑपरेटर शामिल हैं.

🎯 Exam Tip: उन ऑपरेटरों की सूची याद रखें जिन्हें फ्रेंड फ़ंक्शन के साथ ओवरलोड नहीं किया जा सकता, यह अक्सर पूछा जाता है.

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

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

🎯 Exam Tip: अपनी परिभाषा में 'विशेष मीनिंग' और 'डेटा टाइप' शब्दों का उपयोग करें ताकि आपकी परिभाषा सटीक हो.

Question 2. ऑपरेटर फंक्शन का प्रोटोटाईप लिखो।
Answer: ऑपरेटर फंक्शन का प्रोटोटाईप इस प्रकार होता है:
`return_type class_name :: operator op (arguments list)`
`{`
` Function body`
`}`
यहाँ `return_type` फंक्शन का वापसी प्रकार है, `class_name` वह क्लास है जिसका यह सदस्य है, `operator` एक कीवर्ड है, `op` ओवरलोड किया जाने वाला ऑपरेटर है, और `arguments list` फंक्शन को पास किए गए पैरामीटर हैं।
In simple words: ऑपरेटर फंक्शन का प्रोटोटाइप यह बताता है कि यह फंक्शन किस तरह का डेटा वापस करेगा, किस क्लास का है, कौन सा ऑपरेटर इस्तेमाल कर रहा है, और उसे क्या इनपुट चाहिए.

🎯 Exam Tip: प्रोटोटाइप लिखते समय `return_type`, `class_name`, `operator`, `op`, और `arguments list` के सही क्रम और उपयोग पर ध्यान दें.

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

Question 1. ऑपरेटर फंक्शन मेम्बर फंक्शन के रूप में और ऑपरेटर फंक्शन फ्रेंड फंक्शन के रूप में दोनों में अन्तर का वर्णन कीजिए।
Answer: ऑपरेटर फंक्शन को मेम्बर फंक्शन या फ्रेंड फंक्शन के रूप में परिभाषित किया जा सकता है, और इन दोनों में कुछ मुख्य अंतर होते हैं:
1. मेम्बर फंक्शन (Member Function):
- यह क्लास के अंदर परिभाषित होता है और क्लास का सदस्य होता है.
- यह `public`, `private` या `protected` हो सकता है.
- यूनरी ऑपरेटर के लिए यह कोई आरग्यूमेन्ट नहीं लेता है.
- बाइनरी ऑपरेटर के लिए यह एक आरग्यूमेन्ट लेता है.
- यह `this` पॉइंटर का उपयोग करके उस ऑब्जेक्ट को संदर्भित करता है जिस पर ऑपरेटर लागू होता है.
2. फ्रेंड फंक्शन (Friend Function):
- यह क्लास का सदस्य नहीं होता है, लेकिन `friend` कीवर्ड का उपयोग करके इसे क्लास के `private` और `protected` सदस्यों तक पहुँचने की अनुमति दी जाती है.
- यह यूनरी ऑपरेटर के लिए एक आरग्यूमेन्ट लेता है.
- बाइनरी ऑपरेटर के लिए यह दो आरग्यूमेन्ट लेता है.
- इसका उपयोग तब किया जाता है जब ऑपरेटर को दो अलग-अलग क्लासों के बीच काम करना हो या जब ऑपरेटर का बायां ऑपरेंड क्लास का ऑब्जेक्ट न हो.
उदाहरण के तौर पर, यूनरी पोस्टफिक्स इंक्रीमेंट ऑपरेटर `(++)` को मेम्बर फंक्शन के रूप में ओवरलोड करना: एक `point` क्लास जिसमें `x` और `y` सदस्य हैं, उनके मान को एक से बढ़ाने के लिए ऑपरेटर को ओवरलोड किया जाता है.
`#include`
`using namespace std;`
`class point`
`{`
`int x, y;`
`public:`
`void getdata (int a, int b)`
`{`
`x=a;`
`y=b;`
`}`
`void show ()`
`{`
`cout<<"x="<`cout<<"y="<`}`
`void operator++ (int)`
`{`
`x++;`
`y++;`
`}`
`};`
`int main()`
`{`
`point p;`
`p.getdata (5,8);`
`cout<<"p: ";`
`p.show();`
`p++; // invoke operator function`
`cout<<"p++: ";`
`p.show ();`
`return 0;`
`}`
प्रोग्राम का आउटपुट होगा:
`p: x=5 y=8`
`p++: x=6 y=9`
यह दर्शाता है कि `int` का उपयोग करके हम पोस्टफिक्स इंक्रीमेंट ऑपरेटर को ओवरलोड कर रहे हैं, न कि प्रिफिक्स इंक्रीमेंट ऑपरेटर को. अब, यूनरी प्रिफिक्स डिक्रीमेंट ऑपरेटर `(--)` को फ्रेंड फंक्शन के रूप में ओवरलोड करते हैं. यह भी एक ऑपरेंड लेता है और उसके मान को एक कम कर देता है.
`#include`
`using namespace std;`
`class point`
`{`
`int x, y;`
`public:`
`void getdata (int a, int b)`
`{`
`x = a;`
`y = b;`
`}`
`void show (void)`
`{`
`cout<<"x = "<`cout<<"y = "<`}`
`friend void operator-- (point &s)`
`{`
`s.x = s.x-1;`
`s.y = s.y-1;`
`}`
`};`
`int main()`
`{`
`point p;`
`p.getdata (7, 10);`
`cout<<"p: ";`
`p.show();`
`--p;`
`cout<<"--p: ";`
`p.show();`
`return 0;`
`}`
प्रोग्राम का आउटपुट होगा:
`p: x=7 y=10`
`--p: x=6 y=9`
ध्यान दें कि ऑपरेटर फंक्शन में आरग्यूमेन्ट रेफरेंस के द्वारा भेजा गया है. अगर हम वैल्यू के द्वारा भेजते तो यह काम नहीं करता क्योंकि जो बदलाव ऑपरेटर फंक्शन में किए गए हैं वह `main()` फंक्शन में प्रतिबिंबित नहीं होंगे.
In simple words: मेम्बर फंक्शन क्लास का ही हिस्सा होता है और कम इनपुट लेता है, जबकि फ्रेंड फंक्शन क्लास के बाहर होता है पर क्लास के अंदरूनी चीज़ों तक पहुँच सकता है और ज़्यादा इनपुट लेता है. दोनों का इस्तेमाल अलग-अलग स्थितियों में ऑपरेटरों को नया काम सिखाने के लिए किया जाता है.

🎯 Exam Tip: मेम्बर फंक्शन और फ्रेंड फंक्शन के बीच के अंतरों को बिंदुवार याद रखना महत्वपूर्ण है, खासकर आरग्यूमेन्ट की संख्या और एक्सेस क्षमताओं के संबंध में.

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

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

Question 1. जब हम किसी ऑपरेटर को ओवरलोड करते हैं तो क्या इसका मूलरूप बदलता है?
Answer: जब हम किसी ऑपरेटर को ओवरलोड करते हैं, तो इसका मूलरूप नहीं बदलता है, वह बरकरार रहता है। केवल उसका व्यवहार नए डेटा टाइप के लिए बदलता है।
In simple words: ऑपरेटर को ओवरलोड करने पर उसका असली काम नहीं बदलता, बस वह नए तरह के डेटा के साथ नया काम सीख जाता है.

🎯 Exam Tip: यह एक महत्वपूर्ण सिद्धांत है: ऑपरेटर ओवरलोडिंग से ऑपरेटर का मूल अर्थ नहीं बदलता, केवल उसका संदर्भ बदलता है.

Question 2. ऑपरेटर फंक्शन क्या होता है?
Answer: किसी ऑपरेटर को अतिरिक्त मीनिंग देने के लिए हम एक विशेष फंक्शन काम में लेते हैं जिसे ऑपरेटर फंक्शन कहा जाता है। यह फ़ंक्शन तब कॉल होता है जब ओवरलोड किया गया ऑपरेटर ऑब्जेक्ट पर लागू होता है।
In simple words: ऑपरेटर फंक्शन एक ख़ास तरह का फंक्शन है जो किसी ऑपरेटर को नया काम सिखाता है, ताकि वह अलग-अलग चीज़ों पर काम कर सके.

🎯 Exam Tip: ऑपरेटर फ़ंक्शन की परिभाषा में 'अतिरिक्त मीनिंग' और 'विशेष फ़ंक्शन' शब्दों का उपयोग करें.

Question 3. C++ में किसी एक ऑपरेटर का नाम बताइये जिसे ओवरलोड नहीं किया जा सकता।
Answer: C++ में कंडीशनल ऑपरेटर (?:) को ओवरलोड नहीं किया जा सकता है। यह एक कंपाइल-टाइम ऑपरेटर है जिसके लिए खास सिंटेक्स की ज़रूरत होती है।
In simple words: C++ में कंडीशनल ऑपरेटर (?:) को बदला नहीं जा सकता.

🎯 Exam Tip: उन ऑपरेटरों की सूची याद रखें जिन्हें C++ में ओवरलोड नहीं किया जा सकता है.

Question 4. C++ में किस ऑपरेटर को फ्रेंड फंक्शन से ओवरलोड नहीं कर सकते?
Answer: C++ में असाइनमेंट ऑपरेटर (=) को फ्रेंड फंक्शन से ओवरलोड नहीं कर सकते हैं। यह ऑपरेटर हमेशा मेम्बर फ़ंक्शन के रूप में ही ओवरलोड किया जाता है।
In simple words: असाइनमेंट ऑपरेटर (=) को फ़्रेंड फंक्शन से ओवरलोड नहीं कर सकते, उसे सिर्फ़ मेम्बर फंक्शन से ही बदला जा सकता है.

🎯 Exam Tip: यह एक महत्वपूर्ण नियम है कि असाइनमेंट ऑपरेटर को हमेशा मेम्बर फ़ंक्शन के रूप में ओवरलोड किया जाना चाहिए.

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

🎯 Exam Tip: बाइनरी ऑपरेटरों में ऑपरेंड की स्थिति और उनके कार्य को स्पष्ट रूप से समझें.

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

Question 1. C++ में किन ऑपरेटर को ओवरलोड़ नहीं कर सकते?
Answer: C++ में निम्न ऑपरेटर को ओवरलोड नहीं कर सकते:
• क्लास मेम्बर एक्सेस ऑपरेटर (., .*) : यह क्लास के सदस्यों तक पहुँचने के लिए उपयोग होता है.
• स्कोप रिजोल्यूशन ऑपरेटर (::) : यह बताता है कि कोई नाम किस स्कोप से संबंधित है.
• साइज ऑपरेटर (sizeof) : यह किसी डेटा टाइप या वेरिएबल के आकार (मेमोरी में जगह) को बताता है.
• कंडीशनल ऑपरेटर (?:) : यह एक तरह का शॉर्टहैंड इफ-एल्स स्टेटमेंट होता है.
इन ऑपरेटरों का व्यवहार C++ द्वारा तय किया गया है और इसे बदला नहीं जा सकता.
In simple words: C++ में कुछ ऑपरेटर जैसे क्लास मेंबर एक्सेस, स्कोप रिजोल्यूशन, sizeof और कंडीशनल ऑपरेटर को हम नया काम नहीं सिखा सकते, उनका काम तय है.

🎯 Exam Tip: इन चारों ऑपरेटरों की सूची को याद रखना महत्वपूर्ण है, क्योंकि इन्हें ओवरलोड नहीं किया जा सकता.

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

🎯 Exam Tip: आरग्यूमेन्ट की संख्या मेम्बर और फ्रेंड फंक्शन के बीच मुख्य अंतर है, इसे हमेशा याद रखें.

Question 3. किन ऑपरेटर्स को फ्रेंड फंक्शन से ओवरलोड नहीं किया जा सकता है?
Answer: निम्नलिखित ऑपरेटर्स को फ्रेंड फंक्शन से ओवरलोड नहीं किया जा सकता है:
• असाइनमेंट ऑपरेटर (=) : यह ऑपरेटर ऑब्जेक्ट्स को एक-दूसरे को असाइन करने के लिए उपयोग होता है.
• फंक्शन कॉल ऑपरेटर () : यह ऑपरेटर ऑब्जेक्ट को फंक्शन की तरह व्यवहार करने की अनुमति देता है.
• सब्सक्रिप्टिंग ऑपरेटर [] : यह ऑपरेटर एरे या कलेक्शन के तत्वों तक पहुँचने के लिए उपयोग होता है.
• क्लास मेंबर एक्सेस ऑपरेटर (->) : यह पॉइंटर के माध्यम से क्लास के सदस्यों तक पहुँचने के लिए उपयोग होता है.
ये ऑपरेटर हमेशा नॉन-स्टेटिक मेम्बर फ़ंक्शन के रूप में ही ओवरलोड किए जाने चाहिए.
In simple words: कुछ खास ऑपरेटर जैसे असाइनमेंट, फंक्शन कॉल, सबस्क्रिप्टिंग और क्लास मेंबर एक्सेस ऑपरेटर को फ्रेंड फंक्शन से ओवरलोड नहीं किया जा सकता है. उन्हें क्लास के अंदर ही बदलना पड़ता है.

🎯 Exam Tip: इस सूची के ऑपरेटरों को याद रखें; ये वे ऑपरेटर हैं जिन्हें केवल नॉन-स्टेटिक मेम्बर फ़ंक्शन के रूप में ही ओवरलोड किया जा सकता है.

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

Question 1. बाइनरी प्लस ऑपरेटर (+) को ओवरलोड करने का प्रोग्राम लिखिए। अथवा बाइनरी प्लस ऑपरेटर (+) द्वारा दों मैट्रिक्स को जोड़ने का प्रोग्राम लिखिए।
Answer: बाइनरी प्लस ऑपरेटर (+) द्वारा दो मैट्रिक्स को जोड़ने का प्रोग्राम इस प्रकार है:
`class matrix`
`{`
`int mat [2][2];`
`public:`
`void getmatrix (void);`
`matrix operator + (matrix);`
`void showmatrix (void);`
`};`
`void matrix :: getmatrix (void)`
`{`
`for (int i=0;i<2;i++)`
`for (int j=0;j<2;j++)`
`{`
`cout<<"Enter the number:";`
`cin>>mat[i][j];`
`}`
`}`
`matrix matrix::operator+ (matrix m)`
`{`
`matrix temp;`
`for (int i = 0;i<2;i++)`
`for (int j = 0;j<2;j++)`
`temp. mat [i][j] =mat [i] [j] +m. mat [i][j];`
`return temp;`
`}`
`void matrix:: showmatrix (void)`
`{`
`for(int i=0; i<2; i++)`
`{`
`for (int j=0; j<2; j++)`
`cout<`cout<<"\n";`
`}`
`}`
`int main()`
`{`
`matrix m1,m2,m3;`
`m1.getmatrix();`
`m2.getmatrix();`
`m3=m1+m2;`
`cout<<"matrix m1:\n";`
`m1.showmatrix();`
`cout<<"matrix m2:\n";`
`m2.showmatrix ();`
`cout<<"Resultant matrix:\n";`
`m3.showmatrix();`
`return 0;`
`}`
प्रोग्राम का आउटपुट होगा:
`Enter the number: 2`
`Enter the number: 3`
`Enter the number: 1`
`Enter the number: 4`
`Enter the number: 6`
`Enter the number: 7`
`Enter the number: 8`
`Enter the number: 9`
`matrix m1:`
`2 3`
`1 4`
`matrix m2:`
`6 7`
`8 9`
`Resultant matrix:`
`8 10`
`9 13`
In simple words: यह प्रोग्राम C++ में '+' ऑपरेटर को नया काम सिखाता है, ताकि वह दो मैट्रिक्स को एक साथ जोड़ सके. यह पहले मैट्रिक्स के मान लेता है, फिर दूसरे के, और अंत में उन्हें जोड़कर परिणामी मैट्रिक्स दिखाता है.

🎯 Exam Tip: मैट्रिक्स जोड़ के लिए ऑपरेटर ओवरलोडिंग में, सुनिश्चित करें कि सभी मैट्रिक्स के तत्व सही ढंग से जोड़े गए हैं और परिणामी मैट्रिक्स सही आकार का है.

Question 2. बाइनरी प्लस ऑपरेटर को फ्रेंड फंक्शन से ओवरलोड करने का प्रोग्राम लिखिए। अथवा बाइनरी प्लस ऑपरेटर से दो कॉम्पलेक्स संख्याओं को जोड़ने का प्रोग्राम लिखिए।
Answer: बाइनरी प्लस ऑपरेटर को फ्रेंड फंक्शन से ओवरलोड करके दो कॉम्पलेक्स संख्याओं को जोड़ने का प्रोग्राम इस प्रकार है:
`#include`
`using namespace std;`
`class complex`
`{`
`float real;`
`float imag;`
`public:`
`void input (float x, float y)`
`{`
`real=x;`
`imag=y;`
`}`
`friend complex operator+ (complex a, complex b)`
`{`
`complex c;`
`c.real=a.real+b.real;`
`c.imag=a.imag+b.imag;`
`return c;`
`}`
`void show(void)`
`{`
`cout<`}`
`};`
`int main()`
`{`
`complex c1,c2,c3;`
`c1.input (1.6,6.2);`
`c2.input (2.3,3.4);`
`c3=c1+c2; //invoke operator function`
`cout<<"C1=";`
`c1.show();`
`cout<<"C2=";`
`c2.show();`
`cout<<"C3=";`
`c3.show();`
`return 0;`
`}`
यह प्रोग्राम `complex` क्लास के ऑब्जेक्ट्स को जोड़ने के लिए `operator+` को फ्रेंड फंक्शन के रूप में ओवरलोड करता है. `input()` फ़ंक्शन रियल और इमेजिनरी भागों को सेट करता है, `operator+` फ़ंक्शन दो `complex` ऑब्जेक्ट्स को जोड़ता है, और `show()` फ़ंक्शन परिणाम प्रदर्शित करता है. `main()` फ़ंक्शन में, दो `complex` ऑब्जेक्ट्स बनाए जाते हैं, मान दिए जाते हैं, जोड़े जाते हैं, और परिणाम प्रिंट किया जाता है.
In simple words: यह कोड '+' ऑपरेटर को नया काम सिखाता है, ताकि वह दो कॉम्पलेक्स संख्याओं को जोड़ सके. इसमें एक फ्रेंड फंक्शन का इस्तेमाल किया गया है, जो क्लास के बाहर से भी ऑब्जेक्ट के डेटा को एक्सेस करके जोड़ता है.

🎯 Exam Tip: फ्रेंड फंक्शन का उपयोग तब करें जब आप किसी ऑपरेटर को दो अलग-अलग क्लासों या एक नॉन-क्लास टाइप के साथ काम करना चाहते हों, जैसा कि यहाँ `complex` संख्याओं को जोड़ने में दिखाया गया है.