RBSE Solutions Class 11 Computer Science Chapter 2 ‘सी’ भाषा की प्रोग्रामिंग

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

RBSE Class 11 Computer Science Chapter 2 बहुचयनात्मक

 

Question 1. एक ही प्रकार के विभिन्न मानों का समूह कहलाता है
(अ) ऐरे
(ब) फलन
(स) स्ट्रिंग
(द) इनमें से कोई नहीं
Answer: (अ) ऐरे
In simple words: जब हम एक ही तरह के कई मानों को एक साथ रखते हैं, तो उसे ऐरे कहते हैं।

🎯 Exam Tip: ऐरे एक ही डेटा प्रकार के तत्वों का संग्रह होता है, जिसका उपयोग प्रोग्रामिंग में कई संबंधित मानों को एक नाम के तहत स्टोर करने के लिए किया जाता है।

 

Question 2. float arr [3] [2] में कितने अवयव होते हैं?
(अ) 2
(ब) 3
(स) 6
(द) 9
Answer: (स) 6
In simple words: एक ऐरे का आकार पंक्तियों और स्तंभों की संख्या को गुणा करके पता चलता है। यहाँ 3 पंक्तियाँ और 2 स्तंभ हैं, तो कुल 6 अवयव होंगे।

🎯 Exam Tip: 2D ऐरे के कुल अवयवों की संख्या निकालने के लिए, हमेशा पंक्तियों की संख्या को स्तंभों की संख्या से गुणा करें।

 

Question 3. निम्नलिखित में से कौन-सा कथन असत्य है?
(अ) ग्लोबल चर सारे प्रोग्राम में उपयोग किया जा सकता है।
(ब) auto चर main() फलन में घोषित किए जाते हैं।
(स) लोकल चर केवल उसी फलन या ब्लॉक में कार्य नहीं करते हैं।
(द) लोकल चर एक ही नाम से अलग-अलग फलनों में घोषित किये जा सकते हैं।
Answer: (ब) auto चर main() फलन में घोषित किए जाते हैं।
In simple words: `auto` चर किसी भी फ़ंक्शन में घोषित किए जा सकते हैं, न कि केवल `main()` फ़ंक्शन में। यह कथन गलत है क्योंकि वे किसी भी फ़ंक्शन या ब्लॉक के अंदर बनाए जा सकते हैं।

🎯 Exam Tip: `auto` कीवर्ड डिफ़ॉल्ट स्टोरेज क्लास बताता है; `main()` तक सीमित होना एक गलत धारणा है।

 

Question 4. फलन in add(int x) का आह्वान करने के लिए निम्नलिखित में से कौन सा कथन सत्य है?
(स) add(int x);
Answer: (स) add(int x);
In simple words: किसी फ़ंक्शन को कॉल करने के लिए उसके नाम और आवश्यक मानों का उपयोग करते हैं, जैसे यहाँ `add()` फ़ंक्शन को `int x` मान के साथ कॉल किया गया है।

🎯 Exam Tip: फ़ंक्शन को कॉल करते समय, केवल फ़ंक्शन का नाम और तर्क (parameters) पास किए जाते हैं, डेटा प्रकार का उल्लेख नहीं किया जाता है। हालाँकि, दिए गए विकल्प के अनुसार, `add(int x);` को सही माना गया है, जो एक फ़ंक्शन घोषणा की तरह अधिक दिखता है।

 

Question 5. फलन को कितने प्रकार से कॉल कर सकते हैं?
(अ) 2
(ब) 1
(स) 3
(द) 4
Answer: (अ) 2
In simple words: फ़ंक्शन को दो मुख्य तरीकों से बुलाया जा सकता है: मान द्वारा बुलाना (Call by Value) और संदर्भ द्वारा बुलाना (Call by Reference)।

🎯 Exam Tip: मान द्वारा बुलाने में तर्क की एक प्रति (copy) भेजी जाती है, जबकि संदर्भ द्वारा बुलाने में मूल तर्क का पता (address) भेजा जाता है।

 

Question 6. फलन कितने प्रकार के होते हैं?
(अ) 1
(ब) 2
(स) 4
(द) 3
Answer: (ब) 2
In simple words: कंप्यूटर प्रोग्रामिंग में फ़ंक्शन मुख्य रूप से दो प्रकार के होते हैं: लाइब्रेरी फ़ंक्शन (जो पहले से बने होते हैं) और यूज़र-डिफ़ाइंड फ़ंक्शन (जिन्हें हम खुद बनाते हैं)।

🎯 Exam Tip: लाइब्रेरी फ़ंक्शन जैसे `printf()` सामान्य कार्यों के लिए होते हैं, जबकि यूज़र-डिफ़ाइंड फ़ंक्शन विशिष्ट प्रोग्राम आवश्यकताओं को पूरा करते हैं।

 

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

🎯 Exam Tip: पॉइन्टर प्रोग्राम को मेमोरी के साथ सीधे काम करने और डेटा को अधिक कुशलता से एक्सेस करने में मदद करते हैं।

 

Question 8. int B = 10; int * A = &B; printf("%d", *A) प्रिन्ट करेगा :
(अ) 10
(ब) A चर का एड्रेस
(स) B चर का एड्रेस
(द) प्रोग्राम के अनुसार प्रिन्ट करेगा
Answer: (अ) 10
In simple words: जब `*A` का उपयोग करते हैं, तो पॉइन्टर `A` जिस मेमोरी एड्रेस की ओर इशारा कर रहा है, वहाँ स्टोर किए गए मान को दिखाता है। इस मामले में, यह `B` का मान (10) प्रिंट करेगा।

🎯 Exam Tip: `*` ऑपरेटर (डीरेफरेंसिंग ऑपरेटर) पॉइन्टर द्वारा इंगित किए गए मान को प्राप्त करने के लिए उपयोग किया जाता है, जबकि `&` ऑपरेटर (एड्रेस-ऑपरेटर) किसी चर का मेमोरी एड्रेस प्राप्त करने के लिए उपयोग किया जाता है।

 

Question 9. int *A A = (int*) malloc(sizeof(int) *10); printf("%d", A) : प्रिन्ट करेगा :
(अ) A चर का ऐड्रेस
(ब) ऐरे के प्रथम मान एड्रेस
(स) ऐरे का प्रथम मान
(द) कोई मान प्रिन्ट नहीं करेगा
Answer: (ब) ऐरे के प्रथम मान एड्रेस
In simple words: जब आप एक पॉइन्टर वेरिएबल `A` को बिना `*` के प्रिंट करते हैं, तो यह वह मेमोरी एड्रेस दिखाता है जो उसमें स्टोर है। `malloc` से मिली मेमोरी का पहला पता `A` में स्टोर होता है।

🎯 Exam Tip: `malloc()` द्वारा लौटाई गई मेमोरी ब्लॉक का शुरुआती पता पॉइन्टर में स्टोर होता है, जो ऐरे के पहले तत्व का एड्रेस होता है।

 

Question 10. (ब) पूर्णांक चर (स) फ्लोटिंग चर (द) ये सभी
Answer: (द) ये सभी
In simple words: प्रोग्रामिंग में कई तरह के चर होते हैं जैसे पूर्णांक (बिना दशमलव वाले नंबर) और फ्लोटिंग (दशमलव वाले नंबर)।

🎯 Exam Tip: डेटा प्रकार यह तय करता है कि एक चर किस प्रकार का मान स्टोर कर सकता है और उस पर कौन से ऑपरेशन किए जा सकते हैं।

 

Question 11. किसी संरचना के सदस्यों को ऐक्सेस करने हेतु कौन से चिह्न को उपयोग में लेते हैं?
(अ). (dot)
(ब) *
(स)
(द) &
Answer: (अ). (dot)
In simple words: संरचना के अंदर के भागों तक पहुँचने के लिए हम `. `(डॉट) चिन्ह का उपयोग करते हैं।

🎯 Exam Tip: संरचना के सदस्यों को एक्सेस करने के लिए डॉट ऑपरेटर (`.`) का उपयोग किया जाता है, जबकि पॉइन्टर के माध्यम से सदस्यों को एक्सेस करने के लिए एयरो ऑपरेटर (`->`) का उपयोग होता है।

 

Question 12. a = 1011 b = 1111 तथा x = a & b तो x का मान होगा :
(अ) 10
(ब) 11
(स) 12
(द) 13
Answer: (ब) 11
In simple words: `a` (1011 बाइनरी) दशमलव में 11 है, और `b` (1111 बाइनरी) दशमलव में 15 है। जब हम `a` और `b` पर बिटवाइज़ AND ( & ) ऑपरेशन करते हैं, तो परिणाम 1011 बाइनरी होता है, जो दशमलव में 11 है।

🎯 Exam Tip: बिटवाइज़ AND ऑपरेशन में, यदि दोनों बिट 1 हैं तो परिणाम 1 होता है, अन्यथा 0 होता है।

 

Question 13. यदि किसी संघ (Union) में int, float तथा double प्रकार के आँकड़े हैं तो उपर्युक्त संघ के लिए कितनी मेमोरी एलोकेट होगी?
(अ) 2 bytes
(ब) 4 bytes
(स) 10 bytes
(द) 8 bytes
Answer: (द) 8 bytes
In simple words: यूनियन में, मेमोरी सबसे बड़े सदस्य के आकार के बराबर मिलती है। `int` 2 या 4 बाइट, `float` 4 बाइट और `double` 8 बाइट लेता है, तो यूनियन को 8 बाइट मिलेगी।

🎯 Exam Tip: यूनियन का मुख्य उपयोग मेमोरी को बचाने के लिए होता है, क्योंकि इसके सदस्य एक ही मेमोरी स्थान को साझा करते हैं।

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

 

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

🎯 Exam Tip: `return` कथन का उपयोग किसी फ़ंक्शन से मान वापस करने या फ़ंक्शन के निष्पादन को तुरंत समाप्त करने के लिए किया जाता है।

 

Question 2. प्राचल कितने प्रकार के होते हैं?
Answer: प्राचल (Parameters) दो प्रकार के होते हैं:
1. वास्तविक प्राचल (Actual Parameters)
2. औपचारिक प्राचल (Formal/Dummy Parameters)
In simple words: फ़ंक्शन को जानकारी भेजने के दो तरीके होते हैं: एक वास्तविक प्राचल (जो कॉल करते समय देते हैं) और दूसरा औपचारिक प्राचल (जो फ़ंक्शन की परिभाषा में होता है)।

🎯 Exam Tip: वास्तविक प्राचल फ़ंक्शन कॉल में दिए गए मान होते हैं, जबकि औपचारिक प्राचल फ़ंक्शन परिभाषा में उपयोग किए गए प्लेसहोल्डर होते हैं।

 

Question 3. लोकल चर किन्हें कहते हैं?
Answer: लोकल चर वे होते हैं जो किसी फ़ंक्शन या ब्लॉक के अंदर घोषित किए जाते हैं। ये चर केवल उसी फ़ंक्शन या ब्लॉक के अंदर ही काम करते हैं और उनका दायरा उस ब्लॉक तक सीमित होता है।
In simple words: लोकल वेरिएबल सिर्फ उस हिस्से में काम करते हैं जहाँ उन्हें बनाया जाता है, जैसे किसी फ़ंक्शन के अंदर।

🎯 Exam Tip: लोकल चर को उस ब्लॉक के बाहर एक्सेस नहीं किया जा सकता जिसमें उन्हें घोषित किया गया है, और वे मेमोरी में केवल तभी मौजूद रहते हैं जब वह ब्लॉक निष्पादित हो रहा होता है।

 

Question 4. '\0' संप्रतीक किस हेडर फाइल में सम्मिलित होता है?
Answer: '\0' संप्रतीक (`null` कैरेक्टर) `stdio.h` हेडर फाइल में सम्मिलित होता है।
In simple words: '\0' कैरेक्टर `stdio.h` नाम की फाइल में होता है।

🎯 Exam Tip: '\0' कैरेक्टर स्ट्रिंग के अंत का संकेत देता है और यह `stdio.h` लाइब्रेरी में स्ट्रिंग मैनिपुलेशन के लिए महत्वपूर्ण है।

 

Question 5. एक विमा वाली एरे को किस प्रकार घोषित करते हैं?
Answer: एक विमा वाली ऐरे को इस प्रकार घोषित करते हैं:
`<ऐरे का प्रकार> <ऐरे का नाम> [साइज];`
जैसे, `int myArray[10];`
In simple words: ऐरे बनाने के लिए पहले उसका प्रकार (जैसे `int`), फिर नाम (जैसे `myArray`) और फिर ब्रैकेट्स `[]` में उसका साइज (कितने आइटम) लिखते हैं।

🎯 Exam Tip: ऐरे का साइज (कुल अवयवों की संख्या) हमेशा एक पूर्णांक होना चाहिए और यह संकलन (compilation) के समय ही निर्धारित हो जाता है।

 

Question 6. किसी पॉइन्टर चर को किस प्रकार घोषित करते हैं?
Answer: पॉइन्टर चर को घोषित करने के लिए `*` ऑपरेटर का उपयोग करते हैं। इसे इस प्रकार घोषित किया जाता है:
`<डेटा प्रकार> *<पॉइन्टर का नाम>;`
उदाहरण:
`int *A;`
`float *B;`
In simple words: पॉइन्टर बनाने के लिए वेरिएबल के नाम से पहले एक स्टार `*` लगाते हैं और उसका डेटा प्रकार बताते हैं, जैसे `int *ptr;` का मतलब है कि `ptr` एक पॉइन्टर है जो `int` टाइप के डेटा का एड्रेस रखेगा।

🎯 Exam Tip: पॉइन्टर को हमेशा उसी डेटा प्रकार के लिए घोषित किया जाना चाहिए जिसका एड्रेस वह स्टोर करेगा, अन्यथा टाइप मिसमैच (type mismatch) की समस्या हो सकती है।

 

Question 7. int A; A के पते को किस प्रकार प्रिन्ट करते हैं?
Answer: `int A;` नाम के वेरिएबल `A` के पते को प्रिंट करने के लिए इस कमांड का उपयोग करते हैं:
`printf("%u", &A);`
In simple words: किसी वेरिएबल का मेमोरी एड्रेस जानने के लिए `&` (एड्रेस-ऑफ ऑपरेटर) का इस्तेमाल करते हैं और उसे `%u` फॉर्मेट स्पेसिफायर के साथ `printf` से दिखाते हैं।

🎯 Exam Tip: `%u` अनसाइंड पूर्णांक के लिए फॉर्मेट स्पेसिफायर है, जो मेमोरी एड्रेस को प्रिंट करने के लिए आमतौर पर उपयोग किया जाता है।

 

Question 8. free () फलन के द्वारा मैमोरी को कैसे छोड़ते हैं?
Answer: `free()` फ़ंक्शन का उपयोग डायनामिक रूप से एलोकेट की गई मेमोरी को रिलीज़ करने के लिए किया जाता है। इसे इस प्रकार लिखते हैं:
`free(str);`
यहाँ `str` एक पॉइन्टर है जिसे `calloc()` या `malloc()` फ़ंक्शन द्वारा मेमोरी एलोकेट की गई है। `malloc()` फ़ंक्शन `stdlib.h` हेडर फाइल में उपलब्ध होता है।
In simple words: जब आप `malloc` या `calloc` से मेमोरी लेते हैं, तो `free()` कमांड का उपयोग करके उसे वापस ऑपरेटिंग सिस्टम को दे देते हैं ताकि वह मेमोरी खाली हो जाए और कोई और प्रोग्राम उसे इस्तेमाल कर सके।

🎯 Exam Tip: `free()` का उपयोग न करने पर मेमोरी लीक (memory leak) हो सकती है, जिससे प्रोग्राम धीमा हो सकता है या क्रैश हो सकता है। हमेशा `malloc` या `calloc` के बाद `free` का उपयोग करें।

 

Question 9. संरचना में सदस्यों को किस प्रकार घोषित करते हैं?
Answer: संरचना में सदस्यों को घोषित करने का सिंटैक्स (syntax) निम्नलिखित है:
`struct <tag> {`
`<data type> member1;`
`<data type> member2, member3;`
`...`
`<data type> memberN;`
`};`
`variable;`
In simple words: संरचना बनाते समय, हम `struct` कीवर्ड का उपयोग करते हैं, फिर उसका नाम और घुंघराले ब्रैकेट्स `{}` के अंदर उसके सभी सदस्यों (वेरिएबल्स) को उनके डेटा प्रकार के साथ लिस्ट करते हैं।

🎯 Exam Tip: संरचना के सदस्य विभिन्न डेटा प्रकारों के हो सकते हैं और उन्हें घोषणा के क्रम में मेमोरी में आवंटित किया जाता है।

 

Question 10. संरचना के संदस्यों का प्रारम्भिकरण द्वारा मान कैसे लिखते हैं?
Answer: संरचना के सदस्यों का प्रारम्भिकरण (initialization) द्वारा मान लिखने का एक उदाहरण इस प्रकार है:
`struct employee emp1 = { "Sangeeta Gupta", 8000,"153, Arya Nagar", 1200};`
In simple words: संरचना के सदस्यों को शुरुआती मान देने के लिए, संरचना के नाम के बाद एक वेरिएबल बनाते हैं और घुंघराले ब्रैकेट्स `{}` के अंदर, कॉमा लगाकर उनके मानों को क्रम से लिखते हैं।

🎯 Exam Tip: संरचना के सदस्यों को इनिशियलाइज़ करते समय, मानों का क्रम संरचना की परिभाषा में सदस्यों के क्रम से मेल खाना चाहिए।

 

Question 14. हम किसी चर के लिए बिट्स किसके द्वारा एलोकेट करवाते हैं?
Answer: हम किसी चर के लिए मेमोरी में बिट्स (`bits`) को `malloc()` फ़ंक्शन द्वारा एलोकेट करवाते हैं।
In simple words: `malloc()` एक फ़ंक्शन है जो प्रोग्राम को जरूरत पड़ने पर मेमोरी में जगह देता है, जिसे बिट्स के रूप में मापा जाता है।

🎯 Exam Tip: `malloc()` डायनामिक मेमोरी एलोकेशन के लिए उपयोग किया जाता है, जहाँ प्रोग्राम के चलने के दौरान मेमोरी की आवश्यकता होती है और `free()` के साथ इसका सही उपयोग मेमोरी प्रबंधन के लिए महत्वपूर्ण है।

 

Question 15. नया डाटा टाइप बनाने के लिए कौन-सा की-वर्ड काम में लेते हैं?
Answer: नया डेटा टाइप बनाने के लिए `typedef` की-वर्ड का उपयोग किया जाता है।
In simple words: `typedef` एक कमांड है जिससे आप अपने प्रोग्राम में पहले से मौजूद डेटा टाइप के लिए एक नया और छोटा नाम दे सकते हैं।

🎯 Exam Tip: `typedef` का उपयोग मौजूदा डेटा प्रकारों को अधिक पठनीय और उपयोग में आसान बनाने के लिए किया जाता है, खासकर जब जटिल संरचनाओं या पॉइन्टर्स के साथ काम कर रहे हों।

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

 

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

🎯 Exam Tip: लोकल चर फ़ंक्शन के निष्पादन के दौरान ही मेमोरी में रहते हैं और फ़ंक्शन समाप्त होने पर नष्ट हो जाते हैं।

 

Question 2. दो विमाओं वाली एरे की घोषणा का एक उदाहरण लिखो।
Answer: दो विमाओं वाली ऐरे की घोषणा निम्नलिखित प्रकार है:
`<ऐरे का प्रकार> <ऐरे का नाम> [अधिकतम सीमा 1] [अधिकतम सीमा 2];`
उदाहरण:
`int MAT [3] [3] = {{1, 2, 3}, {4, 5, 6}};`
इस ऐरे की कुल क्षमता 9 है, लेकिन दिए गए इनिशियलाइज़ेशन में केवल 6 मान हैं। इसलिए, बाकी तीन मान शून्य (0) होंगे। ऐरे के मान निम्नलिखित होंगे:
`MAT [0] [0] = 1`
`MAT [0] [1] = 2`
`MAT [0] [2] = 3`
`MAT [1] [0] = 4`
`MAT [1] [1] = 5`
`MAT [1] [2] = 6`
`MAT [2] [0] = 0`
`MAT [2] [1] = 0`
`MAT [2] [2] = 0`
In simple words: दो विमाओं वाला ऐरे बनाने के लिए, आप डेटा टाइप, ऐरे का नाम, और फिर दो स्क्वायर ब्रैकेट्स में पंक्तियों और स्तंभों का साइज लिखते हैं। अगर आप सभी जगह मान नहीं देते हैं, तो बाकी जगह कंप्यूटर खुद 0 भर देता है।

🎯 Exam Tip: दो विमाओं वाले ऐरे में, पहले ब्रैकेट में पंक्तियों की संख्या और दूसरे में स्तंभों की संख्या आती है। जब आप ऐरे को इनिशियलाइज़ करते हैं, तो अंदर वाले ब्रैकेट्स `{}` हर पंक्ति को दर्शाते हैं।

 

Question 4. फलन कितने प्रकार के होते हैं?
Answer: फ़ंक्शन को मुख्य रूप से दो भागों में बाँटा जा सकता है:
1. लाइब्रेरी फ़ंक्शन (Library Functions): ये वे फ़ंक्शन होते हैं जो प्रोग्रामिंग भाषा में पहले से ही परिभाषित होते हैं। इन्हें सीधे प्रोग्राम में उपयोग किया जा सकता है। ये अक्सर सामान्य कार्यों के लिए उपयोगी होते हैं और बड़े प्रोग्राम बनाने में मदद करते हैं।
2. प्रयोक्ता परिभाषित फ़ंक्शन (User Defined Functions): ये वे फ़ंक्शन होते हैं जिन्हें उपयोगकर्ता अपनी आवश्यकताओं के अनुसार बनाता है। जब लाइब्रेरी में उपलब्ध फ़ंक्शन किसी खास काम के लिए पर्याप्त नहीं होते, तो ऐसे फ़ंक्शन बनाए जाते हैं। एक प्रोग्राम में कई यूज़र-डिफ़ाइंड फ़ंक्शन हो सकते हैं और उन्हें मुख्य फ़ंक्शन के ऊपर या नीचे कहीं भी लिखा जा सकता है।
सारणी: लाइब्रेरी फ़ंक्शन

In simple words: फ़ंक्शन दो तरह के होते हैं: पहले से बने हुए (लाइब्रेरी) फ़ंक्शन, जो कंप्यूटर में पहले से होते हैं और आप सीधे उपयोग कर सकते हैं; और दूसरे, उपयोगकर्ता द्वारा बनाए गए (यूज़र-डिफ़ाइंड) फ़ंक्शन, जिन्हें आप अपनी जरूरत के हिसाब से खुद बनाते हैं।

🎯 Exam Tip: लाइब्रेरी फ़ंक्शंस के लिए हमेशा सही हेडर फ़ाइल को शामिल करना याद रखें ताकि उनका ठीक से उपयोग किया जा सके। यूज़र-डिफ़ाइंड फ़ंक्शन जटिल कार्यों को सरल मॉड्यूलर हिस्सों में तोड़ने में मदद करते हैं।

 

Question 6. पुनरावर्तन की दो मुख्य कण्डीशन बताइए।
Answer: पुनरावर्तन (Recursion) वह प्रक्रिया है जिसमें एक फ़ंक्शन खुद को तब तक कॉल करता है जब तक कोई विशेष शर्त पूरी नहीं हो जाती। पुनरावर्तन की दो मुख्य शर्तें इस प्रकार हैं:
1. फ़ंक्शन अपने आप को स्वयं आह्वान (call) करे।
2. फ़ंक्शन में कोई ऐसी शर्त होनी चाहिए जिसके पूरा होने पर पुनरावर्तन रुक जाए।
In simple words: रिकर्शन तब होता है जब एक फ़ंक्शन खुद को बार-बार बुलाता है। इसे रोकने के लिए दो मुख्य बातें जरूरी हैं: फ़ंक्शन खुद को बुलाए, और एक ऐसी शर्त हो जो उसे रुकने के लिए मजबूर करे।

🎯 Exam Tip: बेस कंडीशन (वह शर्त जिस पर फ़ंक्शन रुकता है) के बिना, रिकर्सिव फ़ंक्शन एक अनंत लूप में चला जाएगा, जिससे स्टैक ओवरफ्लो (stack overflow) हो सकता है।

 

Question 7. पॉइन्टर चर क्या है?
Answer: पॉइन्टर एक विशेष प्रकार का चर है जो किसी दूसरे चर के मेमोरी एड्रेस को स्टोर करता है। C भाषा में जटिल प्रोग्राम बनाने के लिए पॉइन्टर का उपयोग किया जाता है। कोई भी चर अपने डेटा प्रकार के अनुसार मेमोरी में जगह लेता है। पॉइन्टर चर को घोषित करने के लिए `*` ऑपरेटर का उपयोग करते हैं और पॉइन्टर चर में स्टोर किए गए एड्रेस पर मान ज्ञात करने के लिए भी इसका उपयोग किया जाता है।
In simple words: पॉइन्टर एक वेरिएबल है जो सीधे किसी वैल्यू को स्टोर करने के बजाय, किसी दूसरे वेरिएबल के मेमोरी एड्रेस को अपने अंदर रखता है।

🎯 Exam Tip: पॉइन्टर्स का उपयोग डायनामिक मेमोरी एलोकेशन, डेटा संरचनाओं जैसे लिंक्ड लिस्ट और ट्री, और फ़ंक्शन से कई मान वापस करने के लिए किया जाता है।

 

Question 8. int *A = {10, 20, 30}; अगर A का बेस एड्रेस 2000 है तो सभी मानों के एड्रेस लिखिए।
Answer: यहाँ, `int` डेटा प्रकार को 2 बाइट्स लेता हुआ माना गया है। यदि `A` का बेस एड्रेस 2000 है, तो ऐरे के पाँच अवयवों के एड्रेस इस प्रकार होंगे:
Address of 10 = 2000
Address of 20 = 2002
Address of 30 = 2004
Address of (अंतिम तत्व) = 2006
Address of (अंतिम तत्व) = 2008
ऐरे का नाम `A` भी ऐरे का बेस एड्रेस बताता है। `A` और `&A[0]` दोनों ही ऐरे के पहले अवयव का पता (Base Address) बताते हैं, और ऐरे के अवयव मेमोरी में लगातार स्टोर होते हैं।
In simple words: अगर ऐरे का पहला मान 2000 पते पर है और हर `int` 2 बाइट का है, तो अगला मान 2002 पर होगा, फिर 2004 पर, और इसी तरह।

🎯 Exam Tip: पॉइन्टर अर्थमेटिक (pointer arithmetic) का उपयोग करके ऐरे के तत्वों के माध्यम से नेविगेट करते समय, डेटा प्रकार के आकार के अनुसार एड्रेस बढ़ता है।

 

Question 9. एक पॉइन्टर चर द्वारा एरे को किस प्रकार घोषित करते हैं?
Answer: पॉइन्टर चर द्वारा ऐरे को सीधे घोषित नहीं किया जाता, बल्कि एक सामान्य पॉइन्टर घोषित करके उसे ऐरे के पहले तत्व का एड्रेस असाइन किया जाता है। यह पॉइन्टर तब ऐरे की तरह व्यवहार कर सकता है। उदाहरण:
`#include <stdio.h>`
`#include <conio.h>`
`main()`
`{`
`int *ptr, I;`
`int A [5] = {7, 9, 1, 2, 4};`
`ptr = A;`
`clrscr();`
`for (I = 0; I < 5; I++)`
`{`
`printf("\nI = %d ptr [I] = %d", I, ptr [I]);`
`printf("* (A + I) = %d &ptr [I] = %x", * (A + I), &ptr [I]);`
`printf(" (A + I) = %x", ptr [I]);`
`}`
`getch();`
`}`
आउटपुट निम्नांकित होगा:
I = 0 ptr [I] = 7 * (A + I) = 7 &ptr[I] = ffca (A + I) = ffca
I = 1 ptr [I] = 9 * (A + I) = 9 &ptr[I] = ffcc (A + I) = ffcc
I = 2 ptr [I] = 1 * (A + I) = 1 &ptr[I] = ffce (A + I) = ffce
I = 3 ptr [I] = 2 * (A + I) = 2 &ptr[I] = ffd0 (A + I) = ffd0
I = 4 ptr [I] = 4 * (A + I) = 4 &ptr[I] = ffd2 (A + I) = ffd2
इस प्रोग्राम में पॉइन्टर चर को सामान्य रूप से और ऐरे को पॉइन्टर रूप में उपयोग किया गया है, जो दिखाता है कि एक आयामी ऐरे और पॉइन्टर को आपस में बदला जा सकता है। यह ध्यान रखना जरूरी है कि अगर पॉइन्टर चर में 1 जोड़ा जाता है, तो यह 2 बाइट्स बढ़ता है, क्योंकि यह इसमें स्टोर डेटा प्रकार पर निर्भर करता है। यदि यह `long int` होगा, तो पॉइन्टर चर में 1 जोड़ने पर चार बाइट्स बढ़ेंगे।
In simple words: आप एक पॉइन्टर को ऐरे के पहले आइटम का पता देकर उसे ऐरे की तरह इस्तेमाल कर सकते हैं। फिर आप उस पॉइन्टर का उपयोग करके ऐरे के सभी आइटम तक पहुँच सकते हैं, जैसे कि आप सीधे ऐरे का उपयोग कर रहे हों।

🎯 Exam Tip: ऐरे का नाम खुद उसके पहले तत्व का पता होता है, इसलिए आप `ptr = A;` लिखकर एक पॉइन्टर को सीधे ऐरे असाइन कर सकते हैं। पॉइन्टर अर्थमेटिक (ptr+I) डेटा प्रकार के आकार पर निर्भर करता है।

 

Question 10. संरचना क्या है? समझाइये।
Answer: संरचना (Structure) एक उपयोगकर्ता-परिभाषित डेटा प्रकार है जो विभिन्न डेटा प्रकारों के अवयवों को एक साथ समूहबद्ध कर सकता है। एक संरचना में, उपयोगकर्ता `int`, `float`, `double`, `char`, और ऐरे जैसे अलग-अलग डेटा प्रकारों का उपयोग कर सकता है। संरचना के प्रत्येक अवयव को सदस्य (member) कहते हैं। संरचना में प्रत्येक सदस्य की घोषणा उसके डेटा प्रकार और नाम के साथ की जाती है। यह एक लॉजिकल इकाई के रूप में संबंधित डेटा को प्रबंधित करने में मदद करती है।
In simple words: संरचना एक तरीका है जिससे आप अलग-अलग तरह के डेटा (जैसे नाम, उम्र, पता) को एक साथ एक ही ग्रुप में रख सकते हैं।

🎯 Exam Tip: संरचनाएं डेटा रिकॉर्ड बनाने के लिए बहुत उपयोगी होती हैं, जैसे कर्मचारियों के विवरण या छात्रों की जानकारी को एक साथ स्टोर करना।

 

Question 11. छात्र संरचना जिसके सदस्य name, address, roll no. हैं, लिखिए।
Answer: छात्र संरचना जिसके सदस्य `name`, `address`, और `roll_no` हैं, इस प्रकार होगी:
`struct student`
`{`
`char name [20];`
`int roll_no;`
`char address [50];`
`}`
`S1;`
In simple words: `struct student` नाम का एक स्ट्रक्चर बनाया गया है, जिसमें एक छात्र का नाम (20 अक्षर तक), रोल नंबर (एक संख्या) और पता (50 अक्षर तक) स्टोर किया जा सकता है। `S1` इस स्ट्रक्चर का एक वेरिएबल है।

🎯 Exam Tip: संरचना के सदस्यों को घोषित करते समय, डेटा प्रकार और साइज (यदि लागू हो) को सही ढंग से निर्दिष्ट करना महत्वपूर्ण है।

 

Question 12. बिट् फील्ड्स के द्वारा मेल/फिमेल का मान 0 या 1 स्टोर करने के लिए किस प्रकार घोषित करेंगे।
Answer: बिट फ़ील्ड्स का उपयोग करके `male` या `female` के लिए 0 या 1 मान स्टोर करने के लिए आप इस प्रकार से एक स्ट्रक्चर घोषित कर सकते हैं। प्रश्न में दिए गए उदाहरण में `age` के लिए एक बिट फ़ील्ड दिखाया गया है:
`#include <stdio.h>`
`struct person1`
`{`
`int age: 7;`
`}`
`st1;`
`struct person2`
`{`
`int age;`
`}`
`st2;`
`main()`
`{`
`// male/female के लिए 0 या 1 स्टोर करने का उदाहरण`
`// struct Gender {`
`// unsigned int isMale : 1; // 1 bit for male (1) or female (0)`
`// };`
`// struct Gender myGender;`
`// myGender.isMale = 1; // Male`
`}`
In simple words: बिट फ़ील्ड्स का उपयोग करके आप बहुत कम मेमोरी में डेटा स्टोर कर सकते हैं। जैसे, अगर आपको `male` या `female` (जो 0 या 1 हो सकता है) स्टोर करना है, तो आप सिर्फ 1 बिट का उपयोग करके इसे कर सकते हैं। दिए गए उदाहरण में `age` के लिए 7 बिट का उपयोग दिखाया गया है।

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

 

Question 13. निरूपित आँकड़ों का एक उदाहरण लिखिए।
Answer: निरूपित आँकड़ों का एक उदाहरण ऐरे (Array) है। ऐरे एक चर है जो एक ही प्रकार के आँकड़ों को एक साथ एकत्रित कर सकता है। कई बार ऐसी आवश्यकता होती है जब हमें एक ही प्रकार के कई संबंधित मानों का उपयोग करना होता है। तब यह मुश्किल होता है कि सभी मानों को अलग-अलग नामों में स्टोर किया जाए। इसलिए, एक ही चर के द्वारा इन सभी को दर्शाया जा सकता है। ऐरे के समूह में आँकड़ों का प्रकार `char`, `int`, `float`, `double` आदि हो सकता है।
In simple words: ऐरे एक तरह का डेटा स्ट्रक्चर है जो एक ही तरह के बहुत सारे मानों को एक साथ, एक ही नाम के नीचे रखता है। जैसे, अगर आपको 100 छात्रों के नंबर स्टोर करने हैं, तो आप एक `int` ऐरे बना सकते हैं।

🎯 Exam Tip: ऐरे का उपयोग तब किया जाता है जब आपको समान डेटा प्रकार के कई तत्वों को स्टोर और एक्सेस करने की आवश्यकता होती है, और यह डेटा को व्यवस्थित करने का एक सीधा तरीका प्रदान करता है।

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

 

Question 1. पॉइन्टर के लाभ लिखिये।
Answer: पॉइन्टर (Pointer) एक बहुत उपयोगी और शक्तिशाली टूल है। प्रत्येक चर जिस मेमोरी स्थान पर स्टोर होता है, उसे उस चर का पता (Address) कहते हैं। C भाषा में जटिल और बड़े प्रोग्राम बनाने के लिए पॉइन्टर का उपयोग किया जाता है। पॉइन्टर के निम्नलिखित लाभ हैं:
1. C में पॉइन्टर का उपयोग करके कई कार्य बहुत आसानी से किए जा सकते हैं। उदाहरण के लिए, पॉइन्टर के बिना डायनामिक मेमोरी एलोकेशन (Dynamic Memory Allocation) संभव नहीं है।
2. पॉइन्टर की मदद से डेटा संरचनाएं (Data Structures) बनाई जा सकती हैं।
3. पॉइन्टर का उपयोग करने से प्रोग्राम का निष्पादन समय (execution time) कम हो जाता है।
4. पॉइन्टर की मदद से आप फ़ंक्शन से एक से अधिक मान वापस कर सकते हैं।
5. तर्क पास करते समय (argument passing), पॉइन्टर वेरिएबल की कॉपी के बजाय मूल वेरिएबल पर काम करने में मदद करते हैं।
6. डेटा की सारणी को पॉइन्टर का उपयोग करके कुशलता से नियंत्रित किया जा सकता है।
7. पॉइन्टर के माध्यम से फ़ंक्शन में जानकारी भेजी जा सकती है, जिससे फ़ंक्शन में किए गए बदलाव कॉल किए गए चरों में भी अपने आप बदल जाते हैं।
8. ये प्रोग्राम के निष्पादन की गति बढ़ा देते हैं।
9. इसके द्वारा ऐरे के तत्वों को आसानी से एक्सेस (Access) किया जा सकता है।
10. पॉइन्टर की सहायता से फ़ंक्शन के बाहर घोषित चर को भी एक्सेस किया जा सकता है।
In simple words: पॉइन्टर प्रोग्राम को तेज़ी से चलाने, मेमोरी को अच्छे से इस्तेमाल करने और एक साथ कई काम करने में मदद करते हैं। ये डेटा को इधर-उधर भेजने और फ़ंक्शंस से ज़्यादा जानकारी पाने के लिए बहुत उपयोगी होते हैं।

🎯 Exam Tip: पॉइन्टर्स का उपयोग मेमोरी प्रबंधन और जटिल डेटा संरचनाओं जैसे लिंक्ड लिस्ट और ट्री में उनकी भूमिका के लिए महत्वपूर्ण है।

 

Question 2. पॉइन्टर के द्वारा एरे को किस प्रकार घोषित करते हैं? उदाहरण सहितं समझाइए।
Answer: ऐरे को घोषित करते समय ही उसके लिए मेमोरी में जगह तय हो जाती है, जहाँ ऐरे के अवयव स्टोर होते हैं। ऐरे का बेस एड्रेस उसके पहले अवयव का मेमोरी पता होता है। एक ऐरे को पॉइन्टर के माध्यम से सीधे घोषित नहीं किया जाता, बल्कि एक पॉइन्टर को ऐरे के बेस एड्रेस के साथ इनिशियलाइज़ करके ऐरे के साथ काम किया जाता है।
माना एक ऐरे `A` इस प्रकार घोषित की गई है:
`int A [5] = {7, 9, 15, 12, 14};`
मान लें कि इसका बेस एड्रेस 2000 है। क्योंकि `int` दो बाइट का स्थान घेरता है, इसलिए ऐरे `A` के पाँच अवयव इस प्रकार स्टोर होंगे:
Address of 10 = 2000
Address of 20 = 2002
Address of 30 = 2004
हमें यह भी पता है कि ऐरे का नाम भी ऐरे का बेस एड्रेस बताता है। इसलिए `A` और `&A[0]` दोनों ही ऐरे के पहले अवयव का पता (Base Address) बताते हैं और ऐरे के अवयव मेमोरी में लगातार स्टोर होते हैं।
इसी तरह, पॉइन्टर चर भी उस मेमोरी ब्लॉक के बेस एड्रेस को ही स्टोर करता है। इसलिए, ऐरे और पॉइन्टर को एक-दूसरे के साथ आपस में बदला जा सकता है।
उदाहरण:
`int *ptr;`
`int A [5] = {7, 9, 15, 12, 14};`
`ptr = A;`
उपर्युक्त उदाहरण में `ptr` और `A` दोनों ही ऐरे की तरह काम करेंगे। दोनों को ही हम पॉइन्टर रूप में तथा पारंपरिक रूप में उपयोग कर सकते हैं।
`#include <stdio.h>`
`#include <conio.h>`
`main()`
`{`
`int *ptr, I;`
`int A [5] = {7, 9, 1, 2, 4};`
`ptr = A;`
`clrscr();`
`for (I = 0; I < 5; I++)`
`{`
`printf("\nI = %d ptr [I] = %d", I, ptr [I]);`
`printf("* (A + I) = %d &ptr [I] = %x", * (A + I), &ptr [I]);`
`printf(" (A + I) = %x", ptr [I]);`
`}`
`getch();`
`}`
आउटपुट निम्नांकित होगा:
I = 0 ptr [I] = 7 * (A + I) = 7 &ptr[I] = ffca (A + I) = ffca
I = 1 ptr [I] = 9 * (A + I) = 9 &ptr[I] = ffcc (A + I) = ffcc
I = 2 ptr [I] = 1 * (A + I) = 1 &ptr[I] = ffce (A + I) = ffce
I = 3 ptr [I] = 2 * (A + I) = 2 &ptr[I] = ffd0 (A + I) = ffd0
I = 4 ptr [I] = 4 * (A + I) = 4 &ptr[I] = ffd2 (A + I) = ffd2
इस प्रोग्राम में पॉइन्टर चर को पारंपरिक रूप में और ऐरे को पॉइन्टर रूप में उपयोग किया गया है। यह दर्शाता है कि एक-आयामी ऐरे और पॉइन्टर को आपस में बदला जा सकता है। यहाँ यह समझना महत्वपूर्ण है कि अगर पॉइन्टर चर में 1 जोड़ा जाता है, तो यह 2 बाइट्स बढ़ जाता है। यह इसमें स्टोर डेटा प्रकार पर निर्भर करता है। यदि यह `long int` होगा, तो पॉइन्टर चर में 1 जोड़ने पर चार बाइट्स बढ़ेंगे।
In simple words: आप ऐरे को सीधे पॉइन्टर के रूप में घोषित नहीं कर सकते, बल्कि एक पॉइन्टर को ऐरे का पहला पता देकर उसे ऐरे की तरह इस्तेमाल कर सकते हैं। जब आप एक पॉइन्टर को एक ऐरे के नाम के बराबर सेट करते हैं, तो पॉइन्टर उस ऐरे के पहले आइटम की ओर इशारा करने लगता है।

🎯 Exam Tip: ऐरे का नाम एक स्थिरांक पॉइन्टर (constant pointer) की तरह व्यवहार करता है, जो ऐरे के पहले तत्व के एड्रेस को इंगित करता है। इसलिए, `ptr = A;` स्टेटमेंट पूरी तरह से वैध है।

 

Question 3. संरचना का उपयोग करते हुए 10 नाम, पते तथा फोन नंबर भंडारित करो। इन्हें नाम के वर्णमाला क्रम में व्यवस्थित करो। व्यवस्थित क्रम को प्रिन्ट करने हेतु प्रोग्राम लिखिए।
Answer: यहाँ एक C प्रोग्राम दिया गया है जो संरचनाओं का उपयोग करके 10 व्यक्तियों के नाम, पते और फोन नंबर को स्टोर करता है, फिर उन्हें नाम के अनुसार वर्णमाला क्रम में सॉर्ट करता है और सॉर्ट किए गए डेटा को प्रिंट करता है।
`#include <stdio.h>`
`#include <string.h>`
`#include <conio.h>`
`struct person`
`{`
`char name [10];`
`char address [20];`
`int phn_no;`
`};`
`typedef struct person NAME;`
`NAME stud [10], temp [10];`
`void sort (int N); // function declaration`
`void main ()`
`{`
`int no, i;`
`clrscr();`
`printf("Enter the number of persons\n");`
`scanf("%d", &no);`
`for (i = 0; i < no; i++)`
`{`
`printf("Enter the name of person %d : ", i + 1);`
`gets (stud[i].name);`
`printf("\n Enter the address of person %d : ", i + 1);`
`gets (stud[i].address);`
`printf("\n Enter the phone no. of person %d : ", i + 1);`
`scanf("%d", &stud[i].phn_no);`
`// temp[i] = stud[i]; // This line is commented out in source but if intended for backup/initial copy, it should be here.`
`}`
`printf("\n Names before sorting \n");`
`for (i = 0; i < no; i++)`
`{`
`printf("%s\t%s\t%d\n", stud[i].name, stud[i].address, stud[i].phn_no);`
`}`
`sort (no); // function call`
`printf ("Names after sorting \n");`
`for (i = 0; i < no; i++)`
`{`
`printf("%s\t%s \t %d \n", stud[i].name, stud[i].address, stud[i].phn_no);`
`}`
`getch();`
`}`
`void sort (int n) // Function to sort the given names`
`{`
`int i, j;`
`NAME temp;`
`for (i = 0; i < n - 1; i++)`
`{`
`for (j = i+1; j < n; j++)`
`{`
`if(strcmp (stud[i].name, stud[j].name) > 0)`
`{`
`temp = stud[i];`
`stud [i] = stud [j];`
`stud [j] = temp;`
`}`
`}`
`}`
In simple words: यह प्रोग्राम लोगों के नाम, पते और फोन नंबर को स्टोर करने के लिए स्ट्रक्चर का उपयोग करता है। यह नामों को अल्फाबेटिक क्रम में लगाता है, फिर सॉर्ट होने से पहले और बाद में दोनों तरह से जानकारी दिखाता है।

🎯 Exam Tip: सॉर्टिंग लॉजिक के लिए `strcmp()` फ़ंक्शन का उपयोग करते समय, ध्यान दें कि यह स्ट्रिंग की तुलना करता है और तुलना के परिणाम के आधार पर एक पूर्णांक मान लौटाता है।

 

Question 4. एक स्ट्रिंग को रीड करो तथा उसमें उपयोग वर्णमाला के अक्षरों की आवृत्ति (frequency) ज्ञात करने हेतु 'सी' भाषा का प्रोग्राम लिखिए।
Answer: यहाँ एक C प्रोग्राम दिया गया है जो एक स्ट्रिंग पढ़ता है और उसमें उपयोग होने वाले वर्णमाला के अक्षरों की आवृत्ति (कितनी बार कौन सा अक्षर आया) ज्ञात करता है:
`#include <stdio.h>`
`#include <conio.h>`
`int main()`
`{`
`char string[100];`
`int c = 0, count [26] = {0};`
`printf ("Enter a string\n");`
`gets (string);`
`while (string[c]! = '\0')`
`{`
`if (string[c] >= 'a' && string[c] <= 'z')`
`count(string[c] - 'a' )++;`
`c++;`
`}`
`printf("Frequency of characters:\n");`
`for (c = 0; c < 26; c++)`
`{`
`if (count [c]! = 0)`
`printf("%c occurs %d times in the entered string, \n", c + 'a', count [c]);`
`}`
`return 0;`
`}`
In simple words: यह प्रोग्राम आपसे एक वाक्य (स्ट्रिंग) लेता है। फिर यह हर अक्षर को देखता है और गिनता है कि कौन सा अक्षर कितनी बार आया है। अंत में, यह दिखाता है कि हर अक्षर कितनी बार आया है।

🎯 Exam Tip: अक्षरों की आवृत्ति गिनते समय, ध्यान दें कि प्रोग्राम केवल छोटे अक्षरों (`a` से `z`) को मानता है और बड़े अक्षरों या अन्य प्रतीकों की उपेक्षा करता है। आप बड़े अक्षरों के लिए भी जांच जोड़ सकते हैं।

 

Question 5. फलन के लिए संकेतक किस प्रकार घोषित होते हैं? उदाहरण सहित समझाइए।
Answer: फ़ंक्शन के लिए पॉइन्टर (function pointer) निम्नांकित प्रकार घोषित करते हैं:
`type (*pointer-name) (parameter);`
यहाँ `type` वापसी का डेटा प्रकार है, `pointer-name` पॉइन्टर का नाम है, और `parameter` फ़ंक्शन के पैरामीटर्स हैं।
उदाहरण:
`#include <stdio.h>`
`#include <conio.h>`
`int sum (int x, int y)`
`{`
`return x + y;`
`}`
`int main ()`
`{`
`int (* Fp) (int, int); // Fp एक फ़ंक्शन पॉइन्टर है जो दो int लेता है और एक int लौटाता है।`
`Fp = sum; // Fp को sum फ़ंक्शन का एड्रेस असाइन किया गया है।`
`int s = Fp (10, 15); // फ़ंक्शन पॉइन्टर के माध्यम से फ़ंक्शन को कॉल किया गया है।`
`printf("Sum is %d", s);`
`getch();`
`return 0;`
`}`
In simple words: फ़ंक्शन पॉइन्टर एक खास तरह का पॉइन्टर है जो किसी फ़ंक्शन के मेमोरी एड्रेस को स्टोर करता है। आप इसे एक फ़ंक्शन को सीधे बुलाने के बजाय पॉइन्टर के माध्यम से बुला सकते हैं।

🎯 Exam Tip: फ़ंक्शन पॉइन्टर का उपयोग कॉलबैक फ़ंक्शंस (callback functions) और डायनामिक फ़ंक्शन डिस्पैच (dynamic function dispatch) को लागू करने के लिए किया जाता है, जिससे कोड को अधिक लचीलापन मिलता है।

 

Question 6. निम्नलिखित सदस्यों के लिए बिट् फील्ड्स दशति हुए संरचना लिखिए। (i) be male or female (ii) have one of the eight different hobbies (iii) be single, married, divorcee or widower
Answer: दिए गए सदस्यों के लिए बिट फ़ील्ड्स दर्शाते हुए संरचना इस प्रकार है:
`struct info`
`{`
`char sex : 1; // 1 बिट male (m) या female (f) के लिए`
`char hobby : 3; // 3 बिट 8 विभिन्न शौक (0-7) के लिए`
`char status : 2; // 2 बिट single (s), married (m), divorcee (d) या widower (w) के लिए`
`};`
`struct info f;`
`// मेमोरी मैप (अनुमानित 1-बाइट एलाइनमेंट के साथ)`

यहाँ `sex` को 1 बिट दिया गया है क्योंकि यह केवल दो मान (`male` या `female`) को स्टोर कर सकता है। `hobby` को 3 बिट दिए गए हैं क्योंकि यह 8 विभिन्न शौक (2^3 = 8) को स्टोर कर सकता है। `status` को 2 बिट दिए गए हैं क्योंकि यह 4 विभिन्न वैवाहिक स्थितियों (2^2 = 4) को स्टोर कर सकता है।
In simple words: बिट फ़ील्ड्स से आप बहुत कम मेमोरी में डेटा स्टोर कर सकते हैं। जैसे, `sex` के लिए 1 बिट (क्योंकि यह सिर्फ 'मेल' या 'फीमेल' हो सकता है), `hobby` के लिए 3 बिट (क्योंकि 8 अलग-अलग हॉबी हो सकती हैं), और `status` के लिए 2 बिट (क्योंकि 4 वैवाहिक स्थितियाँ हो सकती हैं) का उपयोग किया जाता है।

🎯 Exam Tip: बिट फ़ील्ड्स का उपयोग करते समय, डेटा प्रकार का ध्यान रखें (जैसे `unsigned int` या `char`) ताकि बिट्स को सही ढंग से व्याख्या किया जा सके। बिट्स की संख्या `2^n` मानों को स्टोर कर सकती है।