उपनेमका प्रोग्राम का एक अलग हिस्सा है जिसका एक नाम होता है और यह अपने अलग कार्य को हल करता है। उपनेमका मुख्य कार्यक्रम की शुरुआत में स्थित है और नाम निर्दिष्ट करके मुख्य कार्यक्रम से लॉन्च (बुलाया) जा सकता है।
सबरूटीन्स का उपयोग करने से आप कोड डुप्लीकेशन से बच सकते हैं यदि आपको अलग-अलग प्रोग्राम में एक ही कोड लिखने की आवश्यकता है .
किसी प्रोग्राम में आयात की गई लाइब्रेरी (उदाहरण के लिए, सिस्टम) में ऐसे रूटीन होते हैं जो पहले से ही किसी के द्वारा संकलित किए जा चुके होते हैं। प्रोग्रामर को यह सोचने की ज़रूरत नहीं है कि उनमें कौन से एल्गोरिदम लागू किए गए हैं, वे केवल उन्हें लागू करते हैं, केवल यह सोचते हुए कि वे वास्तव में क्या कर रहे हैं। यह एक बड़ा समय बचाने वाला है। ऐसा एल्गोरिदम लिखने की कोई आवश्यकता नहीं है जो पहले से किसी और के द्वारा लिखा गया हो।
प्रत्येक सबरूटीन केवल एक कार्य करना चाहिए, या तो कुछ गणना करें, या कुछ डेटा आउटपुट करें, या कुछ और करें।
सबरूटीन, या विधियाँ, दो प्रकार की होती हैं - फ़ंक्शन (वे जो कार्य का परिणाम लौटाते हैं) और प्रक्रियाएं (जो नहीं देतीं)।
चलिए दूसरे प्रकार से शुरू करते हैं। आइए एक सरल उदाहरण लिखने का प्रयास करते हैं।
मान लीजिए हमें स्क्रीन पर "त्रुटि" स्ट्रिंग प्रदर्शित करने की आवश्यकता है हर बार उपयोगकर्ता की गलती के कारण कोड में त्रुटि हो सकती है (उदाहरण के लिए, जब वह गलत डेटा दर्ज करता है)।
यह कथन लिखकर किया जा सकता है
<पूर्व>
Console.WriteLine("त्रुटि");>
अब कल्पना करते हैं कि इस लाइन को प्रोग्राम में कई जगहों पर डालने की जरूरत है। बेशक, आप इसे हर जगह लिख सकते हैं। लेकिन इस समाधान में दो कमियां हैं।
1) इस स्ट्रिंग को कई बार मेमोरी में स्टोर किया जाएगा;
2) अगर हम त्रुटि होने पर आउटपुट बदलना चाहते हैं, तो हमें पूरे प्रोग्राम में इस लाइन को बदलना होगा, जो काफी असुविधाजनक है।
ऐसे मामलों के लिए तरीकों और प्रक्रियाओं की जरूरत होती है।
प्रक्रिया वाला प्रोग्राम ऐसा दिखाई दे सकता है:
सिस्टम का उपयोग करना;
क्लासप्रोग्राम {
स्थैतिक शून्य PrintError() {
कंसोल.राइटलाइन("त्रुटि");
स्थिर शून्य मुख्य () {
PrintError();
}
एक प्रक्रिया शब्द शून्य से शुरू होती है। के बाद प्रक्रिया नाम खाली कोष्ठक लिखे गए हैं।
एक प्रक्रिया में निष्पादित किए जाने वाले सभी कथनों को इंडेंट किया जाता है।
स्टेटिक संशोधक का अर्थ है दिया गया फ़ील्ड, विधि या संपत्ति वर्ग के प्रत्येक ऑब्जेक्ट से संबंधित नहीं होगी, बल्कि उन सभी के लिए एक साथ होगी।
मेन मेथड Main() से पहले मेथड्स और प्रोसीजर लिखे जाते हैं।
एक प्रक्रिया को संदर्भित करने के लिए, मुख्य कार्यक्रम में आपको इसे नाम से कॉल करने की आवश्यकता है और कोष्ठक लिखना न भूलें।
आप किसी कार्यक्रम में किसी प्रक्रिया को कितनी बार कॉल कर सकते हैं।
|
अब कल्पना करते हैं कि उपयोगकर्ता त्रुटि के जवाब में हमें अलग-अलग संदेशों को प्रदर्शित करने की आवश्यकता है, इस पर निर्भर करता है कि क्या आख़िर उसने क्या ग़लती की।
इस स्थिति में, आप प्रत्येक त्रुटि के लिए अपनी कार्यविधि लिख सकते हैं:
शून्य प्रिंट एरर जीरो ()
{
कंसोल.राइटलाइन ("त्रुटि। शून्य से विभाजन!");
}
<पूर्व>
void PrintErrorInput()
{
कंसोल। राइटलाइन ("इनपुट में त्रुटि!");
}
क्या होगा यदि कई और संभावित त्रुटियां हैं? तब यह समाधान हमें शोभा नहीं देगा।
हमें यह सीखने की जरूरत है कि प्रक्रिया को कैसे नियंत्रित किया जाए, यह बताकर कि कौन सा त्रुटि संदेश प्रदर्शित करना है।
ऐसा करने के लिए, हमें उन पैरामीटरों की आवश्यकता है जिन्हें हम प्रक्रिया नाम के बाद कोष्ठक में लिखेंगे
<पूर्व>
void PrintError(string s)
{
कंसोल। राइटलाइन (ओं);
}
इस प्रक्रिया में, s एक पैरामीटर है - एक विशेष चर जो प्रक्रिया को नियंत्रित करने की अनुमति देता है।
पैरामीटर एक वेरिएबल है जिसका मान उपनेमका के संचालन पर निर्भर करता है। उपप्रोग्राम शीर्षलेख में पैरामीटर नामों को अल्पविराम से अलग करके सूचीबद्ध किया गया है। पैरामीटर प्रकार पैरामीटर से पहले लिखा जाता है।
अब, प्रक्रिया को कॉल करते समय, आपको कोष्ठकों में वास्तविक मान निर्दिष्ट करने की आवश्यकता होती है जो असाइन किया जाएगा हमारी प्रक्रिया के अंदर पैरामीटर ( वेरिएबल s) के लिए
<पूर्व>
printError("त्रुटि! शून्य से विभाजन!");
इस मान को तर्क कहा जाता है।
तर्क पैरामीटर मान है जो कॉल करने पर सबरूटीन को दिया जाता है।
तर्क न केवल एक स्थिर मान हो सकता है, बल्कि एक चर या एक अंकगणितीय अभिव्यक्ति भी हो सकता है।< /span>< /span>
|
स्थानीय और वैश्विक चर
अतिरिक्त चर का उपयोग करना अक्सर आवश्यक होता है जो केवल सबरूटीन में उपयोग किया जाएगा। इस तरह के चर को स्थानीय (या स्थानीय) कहा जाता है और केवल उस सबरूटीन के भीतर ही हेरफेर किया जा सकता है जिसमें वे बनाए गए हैं।
लोकल वेरिएबल स्कोप घुमावदार ब्रैकेट वाला ब्लॉक है जिसके भीतर इसे घोषित किया जाता है।
C# में मुख्य प्रोग्राम भी एक सबरूटीन है, इसलिए void Main() के अंदर घोषित सभी वेरिएबल्स स्थानीय चर हैं। अन्य सबरूटीन्स अन्य सबरूटीन्स के स्थानीय वेरिएबल्स के बारे में कुछ भी "जानते" नहीं हैं।
इस प्रकार, एक चर के दायरे (दायरे) को केवल उपनेमका तक सीमित करना संभव है जहां इसकी वास्तव में आवश्यकता है। प्रोग्रामिंग में, इस तकनीक को एनकैप्सुलेशन - वेरिएबल को बाहर से बदलने से छुपा रहा है।
यदि एक चर घोषित करना आवश्यक है जो कार्यक्रम में कहीं भी दिखाई देगा (किसी भी उपनेमका में), तो ऐसे चर सभी उपनेमकाओं के बाहर घोषित किए जाते हैं (नीचे दी गई तालिका से कार्यक्रम 3 देखें)।
ऐसे चरों को वैश्विक कहा जाता है।
C# में, जब प्रोग्राम शुरू होता है, तो सभी वैश्विक चर स्वचालित रूप से शून्य पर सेट हो जाते हैं (बूलियन चर गलत मान लेते हैं)।
तीन कार्यक्रमों का विश्लेषण करें:
<टेबल बॉर्डर = "1" सेलपैडिंग = "1" सेलस्पेसिंग = "1">
<शरीर>
| 1) इस प्रोग्राम में वेरिएबल i लोकल है। सबरूटीन के अंदर एक लोकल वेरिएबल घोषित किया जाता है। |
2) यहां, भले ही मुख्य प्रोग्राम में वेरिएबल i हो (वैल्यू 7 के साथ), वैल्यू 5 के साथ एक नया लोकल वेरिएबल i बनाया जाएगा।
जब इस प्रोग्राम को निष्पादित किया जाता है, तो मान 75 स्क्रीन पर दिखाई देगा। |
3) इस प्रोग्राम का एक ग्लोबल वेरिएबल i है। इसका मान सबरूटीन के अंदर और मुख्य प्रोग्राम के अंदर बदला जा सकता है।
प्रक्रिया वैश्विक चर i के साथ काम करेगी और इसे 2 के बराबर एक नया मान दिया जाएगा। मान 2 प्रदर्शित होता है। |
<टीडी>
स्थैतिक शून्य परीक्षण ()
{
इंट मैं = 5;
कंसोल.लिखें("मैं");
}
<टीडी>
स्थैतिक शून्य परीक्षण ()
{
इंट मैं = 5;
कंसोल.लिखें("मैं");
}
स्थिर शून्य मुख्य ()
{
इंट मैं = 7;
कंसोल.लिखें("मैं");
परीक्षा();
}
<टीडी>
सिस्टम का उपयोग करना;
वर्ग कार्यक्रम
{
int मैं;
स्थैतिक शून्य परीक्षण ()
{
मैं = 2;
}
स्थिर शून्य मुख्य ()
{
परीक्षा();
कंसोल.लिखें("मैं");
}
}
|
कार्य
एक ऐसी प्रक्रिया लिखें जो दो वेरिएबल्स के मानों की अदला-बदली करे।
इस कार्य की ख़ासियत यह है कि हमें कॉलिंग प्रोग्राम के बारे में जानने के लिए प्रक्रिया में किए गए परिवर्तनों की आवश्यकता है।
आइए प्रक्रिया को इस तरह लिखने का प्रयास करें:
स्थैतिक शून्य स्वैप (इंट ए, इंट बी) // प्रक्रिया मापदंडों के इस तरह के विवरण के साथ,
{ // तर्कों के मूल्यों की नकल करेगा (x और y)
इंट सी; // चर ए और बी स्वतंत्र चर हैं जो एक्स और वाई से संबंधित नहीं हैं
सी = ए; ए = बी; बी = सी;
}
स्थिर शून्य मुख्य ()
{
int x=1, y=2;
स्वैप (एक्स, वाई); // चर x और y (तर्क) के मान पैरामीटर a और b, x = 1, y = 2 में कॉपी किए गए हैं
}
यदि आप इस प्रोग्राम को चलाते हैं, तो आप देख सकते हैं कि x और y चर के मान नहीं बदले हैं। मापदंडों के लिए तर्कों के मूल्यों को बदलने के लिए, आपको संदर्भ से गुजरने वाले डेटा का उपयोग करना होगा। ऐसा करने के लिए, सबरूटीन के हेडर में डेटा प्रकार के नाम से पहले, आपको रेफरी लिखना होगा ।
शून्य स्वैप (रेफरी इंट ए, रेफ इंट बी) // अब वेरिएबल्स ए और बी मेमोरी में वेरिएबल्स एक्स और वाई के पते प्राप्त करते हैं
{
इंट सी;
सी = ए; ए = बी; बी = सी;
}
स्थिर शून्य मुख्य ()
{
int x=1, y=2;
स्वैप (रेफरी एक्स, रेफ वाई);
अनुप्रयोग: यदि आप संदर्भ द्वारा एक तर्क पास करते हैं, तो प्रक्रिया को कॉल करते समय केवल चर का नाम (संख्या नहीं और अंकगणितीय अभिव्यक्ति नहीं) इस स्थान पर खड़ा हो सकता है।
आप इस तरह की प्रक्रिया नहीं कह सकते हैं:
<पूर्व>
स्वैप (एक्स, 4);
स्वैप (5+x, y);
|