मिलिए COBOL - भाग 2

ठीक है, आइए अपने परिचित को आगे जारी रखें, पहले लेख में हमने सीखा कि कॉबोल कार्यक्रम में क्या हैं, इसके लेखन के लिए कौन से नियम मौजूद हैं और हमारे पहले कार्यक्रम का शुभारंभ किया। यह आगे बढ़ने का समय है, इस बार हम चर के साथ काम करना शुरू करेंगे और उनके साथ पहले सार्थक कार्य करेंगे।


तो, हमारे कार्यक्रम पर वापस जाएं।

 000100 पहचान प्रभाग।
 000200 कार्यक्रम-आईडी।  HelloWorld।
 000300 * --- यह एक खाली रेखा है।  ---
 000400 पर्यावरण विभाग।
 000500 डेटा विभाजन।
 000600 प्रक्रिया प्रभाग।
 000,700 बेगिन।
 000800 प्रदर्शन "हैलो वर्ल्ड!"।
 000,900 स्टॉप रन।

डेटा प्रभाग में जोड़ें। नई लाइनें, अर्थात् काम-भंडारण अनुभाग अनुभाग। और WS-A और WS-B चर की एक जोड़ी।

यह इस तरह दिखेगा:

 000500 डेटा विभाजन।
 000510 कार्य-संचालन अनुभाग।
 000 520 01 WS-A PIC 999।
 000 530 01 WS-B PIC 9 (3)।
 000 540 01 WS-RESULT PIC9 (6)।

प्रक्रिया प्रभाग में। तदनुसार निम्नलिखित पंक्तियाँ होंगी:

 000,700 बेगिन।
 000800 प्रदर्शन "हैलो मैं आपका नया कैलकुलेटर हूँ!"।
 000900 प्रदर्शन "कृपया 0 से 999 तक पहले नंबर दर्ज करें"।
 001000 ACCEPT WS-A।
 001100 प्रदर्शन "कृपया 0 से 999 तक दूसरी संख्या दर्ज करें"।
 001200 ACCEPT WS-B।
 001300 प्रदर्शन "------------------------------------"।
 001400 प्रदर्शन ""।
 001500 प्रदर्शन "आपके परिणाम हैं:"।
 001600 ADD WS-A को WS-B GIVING WS-RESULT।
 001700 प्रदर्शन "योग है:", WS- परिणाम।
 001800 SUBTRACT WS-A, WS-B GIVING WS-RESULT से।
 001900 प्रदर्शन "घटाना है:", WS- परिणाम।
 002000 बहुविकल्पी WS-A BY-B GIVING WS-RESULT है।
 002100 प्रदर्शन "गुणन है:", WS- परिणाम।
 002200 WS-B GIVING WS-RESULT द्वारा WS-A को विभाजित करें।
 002300 प्रदर्शन "फूट डालो:", WS- परिणाम।
 002400 स्टॉप रन।

परंपरागत रूप से, हम इसे एक्सटेंशन .cob के साथ फाइल में सेव करते हैं और कंपाइलर चलाते हैं। (हम कार्यक्रम के लापता हिस्सों को जोड़ना नहीं भूलेंगे, सही; ;-)

हम उदाहरण के लिए सफलतापूर्वक इकट्ठी निष्पादन योग्य फ़ाइल लॉन्च करते हैं और देखते हैं:

 हेलो मैं आपका नया कैलकुलेटर हूँ!  कृपया पहला नंबर 0 से 999 300 दर्ज करें। कृपया 0 से 999 100 तक दूसरा नंबर दर्ज करें -------------------------------- ---- आपके परिणाम हैं: योग है: ०००४०० घटाना है: ०००२०० गुणा है: ०३०००००० डिवाइड है: ००००००३ 

मैंने 300 और 100 में प्रवेश किया, बाकी कार्यक्रम द्वारा कटौती की गई थी। परिणाम खुद के लिए बोलते हैं, और अब कोड की नई लाइनों पर विचार करते हैं जो हमने अधिक बारीकी से पेश किए हैं।

चलिए नए डेटा डिवीज़न के साथ शुरू करते हैं।

 000510 कार्य-संचालन अनुभाग।  - सामान्य चर का वर्णन करने वाले अनुभाग की शुरुआत के बारे में संकलक को सूचित करता है।

 000 520 01 WS-A PIC 999।
 000 530 01 WS-B PIC 9 (3)।
 000 540 01 WS-RESULT PIC 9 (6)।

सिमेंटिक लोड के दृष्टिकोण से, ये तीन लाइनें समान हैं, वे तीन चर को 01 स्तर के साथ परिभाषित करते हैं, इसके बाद चर (WS-A, WS-B और WS-RESULT) के नाम से, फिर PIC ऑपरेटर (जिसे इसके पुराने रूप में भी लिखा जा सकता है) जैसे PICTURE IS), जो किसी वैरिएबल के प्रारूप और आकार को सेट करता है। और यहां उन लोगों के लिए मुख्य आश्चर्य शुरू होता है जो अन्य भाषाओं से परिचित हैं। आकार और प्रारूप को आवंटित बिट्स की संख्या से नहीं, बल्कि अधिकतम वर्णों की संख्या से इंगित किया जाता है।
हमारे मामले में, हमने दो चर का वर्णन किया है जिसमें एक 3 VALUE नंबर और एक चर जिसमें 6 VALUE नंबर होंगे।

प्रारूप विवरण के बारे में और जानें। 9 - संकलक को बताता है कि चर संख्यात्मक होगा, वर्णों की संख्या अंकों की संख्या को इंगित करती है, यह स्वाभाविक है कि बड़ी संख्या के लिए कुछ लिखने और पढ़ने के लिए असुविधाजनक है 9999999999999 और लेखन फॉर्म 9 (15) था, अर्थात्, समय की संख्या कोष्ठक में इंगित किया गया है। कोष्ठक से पहले चरित्र को दोहराया।

चलो प्रक्रिया प्रभाग पर चलते हैं।
प्रदर्शन - जैसा कि आप कार्यक्रम और इसके आउटपुट से समझ सकते हैं, यह दुनिया के सबसे उपयोगी कार्यों में से एक है। स्क्रीन पर निर्दिष्ट चर या पाठ प्रदर्शित करता है। कस्टम टेक्स्ट को दोहरे उद्धरण चिह्नों "" में संलग्न किया जाना चाहिए। आप कई चर या ग्रंथों को प्रदर्शित कर सकते हैं, जैसा कि देखा गया है

001700 प्रदर्शन "योग है:", WS- परिणाम।

मुख्य बात यह है कि उनके बीच अल्पविराम को भूलना नहीं है।

कार्यक्रम में 4 गणितीय कार्यों का उल्लेख किया गया है:
WS-B GIVING WS-RESULT में ADD WS-A जोड़ना।
SUBTRACT WS-A को WS-B GIVING WS-RESULT से घटाएं।
गुणा गुणा WS-A BY WS-B GIVING WS-RESULT।
WS-A GIVING WS-RESULT द्वारा DIVIDE डिवीजन WS-B।

वे एक ही सिद्धांत पर निर्मित हैं।

<ऑपरेटर> value1 TO / FROM / BY value2 GIVING चर।

मान या तो चर या संख्या सीधे हो सकते हैं, उदाहरण के लिए,

WS-RESULT 10 से 20 दे रहा है।

10 से 20 जोड़ें और डब्ल्यूएस-रिजल्ट में परिणाम (30) लिखें।

यदि GIVING और उसके बाद वाले चर नाम को छोड़ दिया जाता है, तो परिणाम AFTER TO, FROM, BY के बाद चर को लिखा जाता है - हमारे मामले में यह WS-B होगा (लेकिन DIVIDE के मामले में WS-A)।

एक छोटा लेकिन महत्वपूर्ण नोट, लेखन के कुछ अलग प्रकार हैं, उदाहरण के लिए:

ADD 1 2 3 TO WS-B - तदनुसार, पहले 1 + 2 + 3 जोड़ें, और फिर इसे WS-B के मान में जोड़ें और परिणाम को WS-B में लिखें।
आप छोड़ सकते हैं और कर सकते हैं - ADD 1 WS-A 2 WS-B इन सभी मूल्यों को जोड़ता है और परिणाम को WS-B लिखता है। TO के बाद दोनों प्रकार के कई चर निर्दिष्ट किए जा सकते हैं (TO के बाद प्रत्येक चर में TO से पहले मान जोड़ा जाएगा और परिणाम संगत चर को लिखा जाएगा) और GIVING के बाद, फिर उनमें से प्रत्येक में परिणाम लिखा जाएगा। इसी तरह, आप SUBTRACT के साथ काम कर सकते हैं।

MUTIPLY और DIVIDE के मामले में BUT, कई वेरिएबल्स का संकेत GIVING के बाद ही संभव है (और इसे प्रत्येक कंपाइलर के लिए अलग से निर्दिष्ट किया जाना चाहिए)।

इसके अलावा, DIVIDE में रिकॉर्डिंग का दूसरा रूप है।
BY-INT में परिवर्तन के साथ DIVIDE WS-A INTO WS-B GIVING WS-C भी चर का क्रम बदल देता है, जिसका उपयोग करने के लिए उपयोगकर्ता की पसंद बनी रहती है। मैं केवल यही संकेत दूंगा:
DIVIDE WS-A INTO WS-B WS-B / WS-A = WS-B है

डब्लूएस-डब्लू डब्लू डब्लू डब्लू डब्लू डब्लू डब्लू डब्लू डब्लूएस-ए ग्राइविंग डब्लूएस-रिजल्ट
यह WS-B / WS-A = WS-RESULT है

यह महत्वपूर्ण है! BY विकल्प GIVING के बिना काम नहीं करेगा। कार्यक्रम बस एक त्रुटि के कारण संकलन नहीं करता है।

और अंत में, एक छोटा "उपहार" - शायद पाठक पहले से ही आश्चर्यचकित था कि "एक चर के लिए एक मूल्य कैसे निर्दिष्ट किया जाए?"। MOVE का उपयोग करना

WS-A पर 10 से आगे बढ़ें
या WS-B को WS-A से मोव करें
या यहां तक ​​कि WS-A WS-B के लिए 10 मोवे

यह महत्वपूर्ण है! MOVE केवल "आउटपुट" पर कई चर स्वीकार करता है, अर्थात के बाद।

PS और आप शायद उन संख्याओं से हैरान हैं जो हमें आउटपुट पर मिलीं और उनमें शून्य की संख्या? हम अगले लेख में इस पर विचार करेंगे।


Vorontsov "nerfur" व्याचेस्लाव। 2011।

महत्वपूर्ण अद्यतन! दुर्भाग्य से, मैं DIVIDE के लिए एक महत्वपूर्ण कीवर्ड इंगित करना भूल गया।
WS-A GIVING WS-B के द्वारा DIVIDE WS- रिजल्ट रिमाइंडर <चर>

REMAINDER के उपयोग से हम एक वैरिएबल निर्दिष्ट करते हैं जिसमें डिवीजन से रिजल्ट लिखा होता है।