सबरूटीन्स
एक सबरूटीन प्रोग्राम का एक अलग हिस्सा है जिसका एक नाम होता है और यह अपने अलग टास्क को हल करता है। उपनेमका मुख्य कार्यक्रम की शुरुआत में स्थित है और नाम निर्दिष्ट करके मुख्य कार्यक्रम से लॉन्च (बुलाया) जा सकता है।
सबरूटीन्स का उपयोग करने से आप कोड दोहराव से बच सकते हैं, अगर आपको प्रोग्राम में अलग-अलग जगहों पर एक ही कोड लिखने की आवश्यकता है।
पुस्तकालय जो कार्यक्रम में आयात किए जाते हैं (उदाहरण के लिए, गणितीय पुस्तकालय сmath.h) में सबरूटीन होते हैं जो पहले से ही किसी के द्वारा संकलित किए गए हैं। प्रोग्रामर को यह सोचने की ज़रूरत नहीं है कि वे कौन से एल्गोरिदम लागू करते हैं, लेकिन केवल उन्हें लागू करते हैं, केवल यह सोचते हुए कि वे वास्तव में क्या कर रहे हैं। यह एक बड़ा समय बचाने वाला है। ऐसा एल्गोरिदम लिखने की कोई आवश्यकता नहीं है जो पहले से किसी और के द्वारा लिखा गया हो।
प्रत्येक दिनचर्या केवल एक कार्य करना चाहिए, या तो बस कुछ गणना करें, या कुछ डेटा आउटपुट करें, या कुछ और करें।
सबरूटीन दो प्रकार के होते हैं - प्रक्रियाएं और फ़ंक्शन।
सबरूटीन्स कुछ क्रियाएं करते हैं, उदाहरण के लिए, स्क्रीन पर एक निश्चित रूप में परिणाम प्रदर्शित करते हैं (एक साधारण उदाहरण, ऑपरेटर printf() एक मानक सबरूटीन है जो स्क्रीन पर जानकारी प्रिंट करता है)
फंक्शन सबरूटीन्स रिटर्न रिटर्न (नंबर, कैरेक्टर स्ट्रिंग, आदि) जिसे हम मुख्य प्रोग्राम में इस्तेमाल कर सकते हैं।
आइए एक सरल प्रक्रिया लिखने का प्रयास करें:
मान लीजिए कि हम " त्रुटि" हर बार उपयोगकर्ता की गलती के कारण कोड में त्रुटि हो सकती है (उदाहरण के लिए, जब वह गलत डेटा दर्ज करता है)
यह कथन लिखकर किया जा सकता है
cout << "त्रुटि";
और अब कल्पना कीजिए कि इस तरह की लाइन को प्रोग्राम में कई जगहों पर डालने की जरूरत है। बेशक, आप इसे हर जगह लिख सकते हैं। लेकिन इस समाधान में दो कमियां हैं।
1) इस स्ट्रिंग को कई बार मेमोरी में स्टोर किया जाएगा
2) यदि हम त्रुटि होने पर आउटपुट बदलना चाहते हैं, तो हमें पूरे प्रोग्राम में इस लाइन को बदलना होगा, जो काफी असुविधाजनक है
ऐसे मामलों के लिए प्रक्रियाओं की आवश्यकता होती है।
एक प्रक्रिया वाला एक कार्यक्रम इस तरह दिख सकता है:
#शामिल<iostream>
नेमस्पेस एसटीडी का उपयोग करना;
शून्य प्रिंट एरर () // प्रक्रिया विवरण
{
cout << "गलती"; // प्रक्रिया निकाय - आदेश देता है कि प्रक्रिया निष्पादित होगी
}
मुख्य()
{
...
PrintError() // निष्पादन के लिए प्रक्रिया शुरू करें। हम केवल उस प्रक्रिया का नाम निर्दिष्ट करते हैं जिसे हम निष्पादित करना चाहते हैं।
...
प्रिंट त्रुटि ()
...
}
प्रक्रिया शून्य शब्द से शुरू होती है। प्रक्रिया के नाम के बाद खाली कोष्ठक होते हैं।
एक प्रक्रिया में निष्पादित किए जाने वाले सभी कथनों को इंडेंट किया जाता है।
प्रक्रियाओं को main function main()
से पहले लिखा जाता है
एक प्रक्रिया को निष्पादित करने के लिए, मुख्य कार्यक्रम में आपको इसे नाम से बुलाना होगा और कोष्ठक लिखना याद रखना होगा!
आप किसी प्रोग्राम में किसी प्रक्रिया को कितनी भी बार कॉल कर सकते हैं।
|
अब कल्पना करते हैं कि उपयोगकर्ता की त्रुटि के जवाब में हमें अलग-अलग संदेशों को प्रदर्शित करने की आवश्यकता है, यह इस बात पर निर्भर करता है कि उसने किस प्रकार की गलती की है।
इस स्थिति में, आप प्रत्येक त्रुटि के लिए अपनी कार्यविधि लिख सकते हैं:
शून्य प्रिंट एरर जीरो ()
{
cout << "त्रुटि. शून्य से विभाजन!";
}
शून्य प्रिंट त्रुटि इनपुट ()
{
cout << "इनपुट में त्रुटि!";
}
क्या होगा यदि कई और संभावित त्रुटियां हैं? यह समाधान हमें शोभा नहीं देगा!
हमें यह सीखने की जरूरत है कि प्रक्रिया को कैसे नियंत्रित किया जाए, यह बताकर कि कौन सा त्रुटि संदेश प्रदर्शित करना है।
ऐसा करने के लिए, हमें उन मापदंडों की आवश्यकता होती है जिन्हें हम प्रक्रिया के नाम के बाद कोष्ठक में लिखेंगे
शून्य प्रिंट त्रुटि (तारों)
{
cout << एस;
}
इस प्रक्रिया में, एस एक पैरामीटर है - एक विशेष चर जो आपको प्रक्रिया को नियंत्रित करने की अनुमति देता है।
पैरामीटर एक वेरिएबल है जो यह निर्धारित करता है कि सबरूटीन कैसे काम करता है। उपप्रोग्राम शीर्षलेख में पैरामीटर नामों को अल्पविराम से अलग करके सूचीबद्ध किया गया है। पैरामीटर प्रकार पैरामीटर से पहले लिखा जाता है।
अब, प्रक्रिया को कॉल करते समय, आपको ब्रैकेट में वास्तविक मान इंगित करना होगा जो हमारी प्रक्रिया के अंदर पैरामीटर (चर एस) को असाइन किया जाएगा
PrintError("त्रुटि! शून्य से विभाजन!");
इस मान को तर्क कहा जाता है।
तर्क पैरामीटर मान है जो कॉल करने पर सबरूटीन को दिया जाता है।
एक तर्क न केवल एक स्थिर मान हो सकता है, बल्कि एक चर या अंकगणितीय अभिव्यक्ति भी हो सकता है।
|
स्थानीय और वैश्विक चर
अतिरिक्त चर का उपयोग करना अक्सर आवश्यक होता है जो केवल सबरूटीन में उपयोग किया जाएगा। ऐसे वेरिएबल्स स्थानीय (या स्थानीय) कहलाते हैं और केवल उसी उपनेमका में हेरफेर किए जा सकते हैं जिसमें वे बनाए गए हैं।
लोकल वेरिएबल स्कोप घुमावदार ब्रैकेट वाला ब्लॉक है जिसके भीतर इसे घोषित किया गया है
C++ में मुख्य प्रोग्राम भी एक सबरूटीन है, इसलिए main() के अंदर घोषित सभी वेरिएबल्स लोकल वेरिएबल्स हैं।
अन्य सबरूटीन्स अन्य सबरूटीन्स के स्थानीय वेरिएबल्स के बारे में कुछ भी "जानते" नहीं हैं।
इस प्रकार, एक चर के दायरे (दायरे) को केवल उपनेमका तक सीमित करना संभव है जहां इसकी वास्तव में आवश्यकता है। प्रोग्रामिंग में, इस तकनीक को एनकैप्सुलेशन - किसी वेरिएबल को बाहर से बदलने से छिपाना।
यदि एक चर घोषित करना आवश्यक है जो कार्यक्रम में कहीं भी दिखाई देगा (किसी भी उपनेमका में), तो ऐसे चर सभी उपनेमकाओं के बाहर घोषित किए जाते हैं (नीचे दी गई तालिका से कार्यक्रम 3 देखें)।
ऐसे चर वैश्विक कहलाते हैं।
C++ में, जब प्रोग्राम शुरू होता है, तो सभी वैश्विक चर स्वचालित रूप से शून्य पर सेट हो जाते हैं (बूलियन चर गलत मान लेते हैं )।
तीन कार्यक्रमों का विश्लेषण करें:
<तालिका संरेखण = "केंद्र" सीमा = "1" सेलपैडिंग = "1" सेलस्पेसिंग = "1" शैली = "चौड़ाई: 95%">
<शरीर>
| 1) इस प्रोग्राम में वेरिएबल i लोकल है। सबरूटीन | के अंदर एक स्थानीय चर घोषित किया जाता है
2) यहां, भले ही मुख्य प्रोग्राम में वेरिएबल i हो (वैल्यू 7 के साथ), वैल्यू 5 के साथ एक नया लोकल वेरिएबल i बनाया जाएगा।
जब आप इस प्रोग्राम को चलाते हैं, तो स्क्रीन पर मान 75 | प्रदर्शित होगा
3) इस प्रोग्राम में एक ग्लोबल वेरिएबल i. है, इसकी वैल्यू सबरूटीन के अंदर और मुख्य प्रोग्राम के अंदर बदली जा सकती है
प्रक्रिया वैश्विक चर i के साथ काम करेगी और इसे 2 के बराबर एक नया मान दिया जाएगा। मूल्य 2 | स्क्रीन पर प्रदर्शित होता है
<टीडी>
शून्य परीक्षण ()
{
इंट मैं = 5;
cout << मैं;
}
<टीडी>
शून्य परीक्षण ()
{
इंट मैं = 5;
cout << मैं;
}
मुख्य()
{
इंट मैं = 7;
cout << मैं;
परीक्षा();
}
<टीडी>
#शामिल <iostream>
नेमस्पेस एसटीडी का उपयोग करना;
int मैं;
शून्य परीक्षण ()
{
मैं = 2;
}
मुख्य()
{
परीक्षा();
cout << मैं;
}
|
कार्य
एक ऐसी प्रक्रिया लिखें जो दो वेरिएबल्स के मानों की अदला-बदली करे।
इस कार्य की ख़ासियत यह है कि हमें कॉलिंग प्रोग्राम के बारे में जानने के लिए प्रक्रिया में किए गए परिवर्तनों की आवश्यकता है।
आइए प्रक्रिया को इस तरह लिखने का प्रयास करें:
शून्य स्वैप (इंट ए, इंट बी) // प्रक्रिया मापदंडों के इस तरह के विवरण के साथ,
{ // तर्कों के मान (x और y) कॉपी किए जाएंगे,
इंट सी; // चर ए और बी स्वतंत्र चर हैं जो एक्स और वाई से संबंधित नहीं हैं
सी = ए; ए = बी; बी = सी;
}
मुख्य()
{
int x=1, y=2;
स्वैप (एक्स, वाई); // चर x और y (तर्क) के मान पैरामीटर a और b में कॉपी किए गए हैं
cout << "एक्स=" << एक्स&एलटी;&एलटी; ", य=" << वाई; // एक्स = 1, वाई = 2
}
यदि आप इस प्रोग्राम को चलाते हैं, तो आप देख सकते हैं कि वेरिएबल्स x और y के मान नहीं बदले हैं। मापदंडों के लिए तर्कों के मूल्यों को बदलने के लिए, आपको संदर्भ द्वारा डेटा पास करना चाहिए। ऐसा करने के लिए, डेटा प्रकार के नाम के बाद उपनेमका के शीर्षक में, आपको & ("ampersand") चिन्ह लगाना होगा।
शून्य स्वैप ( int & a, int & b) // अब वेरिएबल्स a और b को मेमोरी में वेरिएबल्स x और y के एड्रेस मिलते हैं
{
इंट सी;
सी = ए; ए = बी; बी = सी;
}
उपयोग: यदि आप संदर्भ द्वारा तर्क पारित करते हैं, तो प्रक्रिया को कॉल करते समय केवल चर नाम (संख्या नहीं और अंकगणितीय अभिव्यक्ति नहीं) इस स्थान पर हो सकता है!< बीआर />
इस तरह की प्रक्रिया को कॉल न करें:
स्वैप (x, 4);
स्वैप (5+x, y);
|