सबरूटीन्स: प्रक्रियाएं और कार्य - 1

सबरूटीन्स के उपयोग से आप कोड दोहराव से बच सकते हैं, यदि आपको प्रोग्राम में अलग-अलग जगहों पर एक ही कोड लिखने की आवश्यकता हो। 
पुस्तकालय जो एक कार्यक्रम में आयात किए जाते हैं (उदाहरण के लिए, गणित पुस्तकालय गणित) में सबरूटीन्स होते हैं जो पहले से ही किसी के द्वारा संकलित किए गए हैं। प्रोग्रामर को यह सोचने की ज़रूरत नहीं है कि वे कौन से एल्गोरिदम लागू करते हैं, लेकिन केवल उन्हें लागू करते हैं, केवल यह सोचते हुए कि वे वास्तव में क्या कर रहे हैं। यह एक बड़ा समय बचाने वाला है। ऐसा एल्गोरिदम लिखने की कोई आवश्यकता नहीं है जो पहले से किसी और के द्वारा लिखा गया हो।

प्रत्येक दिनचर्या केवल एक ही काम करना चाहिए:  या तो बस कुछ गणना करें, या कुछ डेटा आउटपुट करें, या कुछ और करें। 

सबरूटीन दो प्रकार के होते हैं - प्रक्रियाएंऔर फ़ंक्शंस

सबरूटीन कुछ क्रियाएं करते हैं, जैसे एक निश्चित रूप में स्क्रीन पर परिणाम प्रिंट करना (एक साधारण उदाहरण, कथन writeln() एक मानक सबरूटीन है जो प्रिंट करता है स्क्रीन जानकारी)

फंक्शन सबरूटीन्स रिटर्न रिटर्न (नंबर, कैरेक्टर स्ट्रिंग, आदि) जिसे हम मुख्य प्रोग्राम में इस्तेमाल कर सकते हैं।

आइए एक सरल प्रक्रिया लिखने का प्रयास करें:
मान लीजिए हमें स्क्रीन पर "त्रुटि" स्ट्रिंग प्रदर्शित करने की आवश्यकता है हर बार उपयोगकर्ता की गलती के कारण कोड में त्रुटि हो सकती है (उदाहरण के लिए, जब वह गलत डेटा दर्ज करता है)
यह कथन लिखकर किया जा सकता है <पूर्व> राइटलन('त्रुटि'); और अब कल्पना कीजिए कि इस तरह की लाइन को प्रोग्राम में कई जगहों पर डालने की जरूरत है। बेशक, आप इसे हर जगह लिख सकते हैं। लेकिन इस समाधान में दो कमियां हैं।
1) इस स्ट्रिंग को कई बार मेमोरी में स्टोर किया जाएगा
2) यदि हम त्रुटि होने पर आउटपुट बदलना चाहते हैं, तो हमें पूरे प्रोग्राम में इस लाइन को बदलना होगा, जो काफी असुविधाजनक है

ऐसे मामलों के लिए प्रक्रियाओं की आवश्यकता होती है।
एक प्रक्रिया वाला एक कार्यक्रम इस तरह दिख सकता है: <पूर्व> ... नेमस्पेस एसटीडी का उपयोग करना; प्रक्रिया प्रिंट एरर (); // प्रक्रिया विवरण शुरू राइटलन ('त्रुटि'); // प्रक्रिया निकाय - आदेश देता है कि प्रक्रिया निष्पादित होगी अंत; // मुख्य कार्यक्रम शुरू करना; ... प्रिंटररर (); // निष्पादन के लिए प्रक्रिया शुरू करें। हम केवल उस प्रक्रिया का नाम निर्दिष्ट करते हैं जिसे हम निष्पादित करना चाहते हैं। ... प्रिंटररर (); ... अंत। प्रक्रिया प्रक्रिया शब्द से शुरू होती है। प्रक्रिया के नाम के बाद, कोष्ठक लिखे जाते हैं, जो वेरिएबल्स और उनके प्रकारों को इंगित करते हैं जिन पर प्रक्रिया का निष्पादन निर्भर करता है। उदाहरण के लिए:

var a, b, उत्तर: पूर्णांक;
प्रक्रिया योग (ए, बी: पूर्णांक);
शुरू
    उत्तर := ए + बी;
अंत;

एक प्रक्रिया में निष्पादित किए जाने वाले सभी कथनों को इंडेंट किया जाता है। 

प्रक्रियाएं मुख्य कार्यक्रम से पहले लिखी जाती हैं

एक प्रक्रिया को निष्पादित करने के लिए, मुख्य कार्यक्रम में आपको इसे नाम से बुलाना होगा और कोष्ठक लिखना याद रखना होगा!
आप किसी प्रोग्राम में किसी प्रक्रिया को कितनी भी बार कॉल कर सकते हैं।

अब कल्पना करते हैं कि उपयोगकर्ता की त्रुटि के जवाब में हमें अलग-अलग संदेशों को प्रदर्शित करने की आवश्यकता है, यह इस बात पर निर्भर करता है कि उसने किस प्रकार की गलती की है।
इस स्थिति में, आप प्रत्येक त्रुटि के लिए अपनी कार्यविधि लिख सकते हैं:   <पूर्व> प्रक्रिया PrintErrorZero (); शुरू राइटलन ('त्रुटि। शून्य से विभाजन!'); अंत; <पूर्व> प्रक्रिया PrintErrorInput (); शुरू राइटलन (' इनपुट में त्रुटि!'); अंत; क्या होगा यदि कई और संभावित त्रुटियां हैं? यह समाधान हमें शोभा नहीं देगा!
हमें यह सीखने की जरूरत है कि प्रक्रिया को कैसे नियंत्रित किया जाए, यह बताकर कि कौन सा त्रुटि संदेश प्रदर्शित करना है।
ऐसा करने के लिए, हमें उन मापदंडों की आवश्यकता होती है जिन्हें हम प्रक्रिया के नाम के बाद कोष्ठक में लिखेंगे <पूर्व> प्रक्रिया PrintError(s: string); शुरू लेख; अंत; इस प्रक्रिया में, एस एक पैरामीटर है - एक विशेष चर जो आपको प्रक्रिया को नियंत्रित करने की अनुमति देता है।
अब, प्रक्रिया को कॉल करते समय, आपको ब्रैकेट में वास्तविक मान इंगित करना होगा जो हमारी प्रक्रिया के अंदर पैरामीटर (चर एस) को असाइन किया जाएगा <पूर्व> PrintError('त्रुटि! शून्य से विभाजन!'); इस मान को तर्क कहा जाता है।

तर्क पैरामीटर मान है जो कॉल करने पर सबरूटीन को दिया जाता है।

एक तर्क न केवल एक स्थिर मान हो सकता है, बल्कि एक चर या अंकगणितीय अभिव्यक्ति भी हो सकता है।

अतिरिक्त चर का उपयोग करना अक्सर आवश्यक होता है जो केवल सबरूटीन में उपयोग किया जाएगा। ऐसे वेरिएबल्स स्थानीय (या स्थानीय) कहलाते हैं और केवल उसी उपनेमका में हेरफेर किए जा सकते हैं जिसमें वे बनाए गए हैं।
 
इस प्रकार, एक चर के दायरे (दायरे) को केवल उपनेमका तक सीमित करना संभव है जहां इसकी वास्तव में आवश्यकता है। प्रोग्रामिंग में, इस तकनीक को एनकैप्सुलेशन  - किसी वेरिएबल को बाहर से बदलने से छिपाना।

यदि एक चर घोषित करना आवश्यक है जो कार्यक्रम में कहीं भी दिखाई देगा (किसी भी उपनेमका में), तो ऐसे चर सभी उपनेमकाओं के बाहर घोषित किए जाते हैं (नीचे दी गई तालिका से कार्यक्रम 3 देखें)
ऐसे चर वैश्विक कहलाते हैं।

तीन कार्यक्रमों का विश्लेषण करें: <तालिका संरेखण = "केंद्र" सीमा = "1" सेलपैडिंग = "1" सेलस्पेसिंग = "1" शैली = "चौड़ाई: 95%"> <शरीर>

समस्या: एक ऐसी प्रक्रिया लिखें जो दो चरों के मानों की अदला-बदली करे।
इस कार्य की ख़ासियत यह है कि हमें कॉलिंग प्रोग्राम के बारे में जानने के लिए प्रक्रिया में किए गए परिवर्तनों की आवश्यकता है।

आइए प्रक्रिया को इस प्रकार लिखने का प्रयास करें:

वर एक्स, वाई: पूर्णांक; <पूर्व> प्रक्रिया स्वैप (ए, बी: पूर्णांक); // प्रक्रिया मापदंडों के ऐसे विवरण के साथ, वर सी: पूर्णांक; start // तर्कों के मूल्यों की नकल करेगा (x और y) // चर ए और बी स्वतंत्र चर हैं जो एक्स और वाई से संबंधित नहीं हैं सी := ए; ए: = बी; ख := ग; अंत; शुरू एक्स: = 1;   य := 2; स्वैप (एक्स, वाई); // चर x और y (तर्क) के मान पैरामीटर a और b में कॉपी किए गए हैं राइटलन('x = ', x, ', y = ', y); // एक्स = 1, वाई = 2 अंत। यदि आप इस प्रोग्राम को चलाते हैं, तो आप देख सकते हैं कि चर x और y के मान नहीं बदले हैं। मापदंडों के लिए तर्कों के मूल्यों को बदलने के लिए, आपको संदर्भ द्वारा डेटा पास करना चाहिए। ऐसा करने के लिए, डेटा प्रकार के नाम के बाद उपनेमका के शीर्षक में, आपको वर   शब्द डालना होगा <पूर्व> प्रक्रिया स्वैप (var a, b: पूर्णांक);   // अब वेरिएबल्स a और b को मेमोरी में वेरिएबल्स x और y के एड्रेस मिलते हैं वर सी: पूर्णांक;  शुरू सी := ए; ए: = बी; ख := ग; अंत; उपयोग: यदि आप संदर्भ द्वारा तर्क पारित करते हैं, तो प्रक्रिया को कॉल करते समय केवल चर नाम (संख्या नहीं और अंकगणितीय अभिव्यक्ति नहीं) इस स्थान पर हो सकता है!< बीआर />
इस तरह की प्रक्रिया को कॉल न करें: <पूर्व> स्वैप (एक्स, 4); स्वैप (5+x, y);