GOTO का निषिद्ध फल मीठा है (माइक्रोकंट्रोलर के लिए संस्करण)!

आपका दिन शुभ हो!

C / C ++ में गोटो ऑपरेटर के लिए आपका दृष्टिकोण क्या है? सबसे अधिक संभावना है, जब आपने प्रोग्राम करना सीखा, तो आपने इसका उपयोग किया। तब आपको पता चला कि यह खराब था, और आप इसके बारे में भूल गए। हालांकि कभी-कभी जटिल त्रुटि से निपटने के साथ ... नहीं, नहीं, वहां कोशिश करें ... फेंकें ... पकड़ें। या नेस्टेड छोरों से बाहर निकलने के लिए ... नहीं, झंडे और बहुत सारी कठिनाइयां हैं। या जब नेस्टेड स्विच ... नहीं, नहीं, नहीं, वही झंडे हैं।
और फिर भी, कभी-कभी रात के सन्नाटे में आपने अपने अवचेतन मन में एक पापपूर्ण विचार की अनुमति दी - " यहाँ गोटो का उपयोग क्यों नहीं किया जाता है ?" और कार्यक्रम पतला लगता है, और आशावादी रूप से सामने आता है। हाँ, यह अच्छा होगा ... लेकिन नहीं - यह असंभव है , वे भूल गए! "
ऐसा क्यों है?
कई वर्षों के अभ्यास और विभिन्न प्लेटफार्मों के आधार पर, कट के तहत एक छोटी जांच और इस मुद्दे पर मेरा दृष्टिकोण है। यह लेख C ++ के लिए उसी का एक एनालॉग है, लेकिन यहां विशेष रूप से C और माइक्रोकंट्रोलर के लिए हाइलाइट किए गए हैं।

गोटो के कट्टर विरोधियों से अनुरोध करें - मुझे केवल कर्म के नरक की आग में न उखाड़ फेंकें क्योंकि मैंने इस विषय को उठाया और गोटो का आंशिक समर्थक हूं!

एक छोटा सा ऐतिहासिक भ्रमण

उन लोगों के लिए जो पहले से ही पूरी तरह से अच्छी तरह से जानते हैं कि एक कॉम्बिनेशन सर्किट, मेमोरी के साथ एक सर्किट और यह कैसे असेंबलर से विकसित हुआ, आप सुरक्षित रूप से आगे छोड़ सकते हैं - निष्कर्ष तक।

और यह सब कॉम्बिनेशन सर्किट के साथ शुरू हुआ

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

दूसरे शब्दों में, आपको एक ऐसा उपकरण बनाने की आवश्यकता है, जो चर के मान से, फ़ंक्शन का मान पाए।

इस कठिन समस्या को हल करने के लिए, अंकगणितीय ऑपरेशन करने के लिए एक अनुक्रमिक एल्गोरिथ्म का निर्माण किया गया था (इस तरह के एल्गोरिथम में गणना की एक सटीकता के मामले में, प्रत्येक अंकगणितीय ऑपरेशन एक घड़ी चक्र में किया जा सकता है)।

एक एल्गोरिथ्म होने के साथ, एक कॉम्बिनेशन सर्किट का निर्माण करना मुश्किल नहीं है - एक सर्किट जो तुरंत (तर्क उपकरणों के संचालन तक और संकेतों के प्रसार समय तक) आउटपुट पर एक उत्तर देता है।
सवाल है - क्या आपको यहां किसी बदलाव की जरूरत है? नहीं, वे बस वहां नहीं हैं। कार्रवाई का एक सुसंगत पाठ्यक्रम है। अंततः, इन सभी कार्यों को एक ही घड़ी चक्र में लागू किया जा सकता है (मैं यह तर्क नहीं देता, यह बहुत, बहुत ही बोझिल होगा, लेकिन सभी आंकड़ों की थोड़ी गहराई को देखते हुए, कोई भी छात्र आपके लिए ऐसी योजना का निर्माण करेगा, अकेले VHDL या वेरिलॉग के लिए एक सिंथेसाइज़र बनाएं)।

लेकिन फिर मेमोरी सर्किट में हस्तक्षेप हुआ

और फिर किसी का स्मार्ट हेड एक प्रतिक्रिया सर्किट के साथ आया - उदाहरण के लिए, एक आरएस ट्रिगर। और फिर सर्किट की स्थिति दिखाई दी। और राज्य स्मृति के साथ सभी तत्वों के वर्तमान मूल्य के अलावा कुछ भी नहीं है।

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

सवाल यह है कि क्या कोई संक्रमण हैं? निश्चित रूप से हाँ! इसके अलावा, बिना शर्त संक्रमण दिखाई देते हैं (अगले कमांड का पता डेटा की वर्तमान स्थिति पर निर्भर नहीं करता है) और सशर्त (अगले कमांड का पता डेटा की स्थिति पर निर्भर करता है)।

क्या उनके बिना ऐसा करना संभव है? कोई रास्ता नहीं! यदि हम बदलावों का उपयोग नहीं करते हैं, तो हम बिना मेमोरी के कॉम्बिनेशन सर्किट में लौट आएंगे।

परिणामस्वरूप, हम असेंबलर के पास आए

ऐसे कंप्यूटिंग उपकरणों के एपोथोसिस सूक्ष्म, सरल और सुपर कंप्यूटर बन गए हैं। वे सभी मूल रूप से एक कोड भाषा पर आधारित होते हैं जिन्हें लगभग समान आदेशों के साथ आसानी से कोडांतरक में बदला जा सकता है। माइक्रोकंट्रोलर्स के एक निश्चित औसत संयोजक पर विचार करें (मैं ATmeg, PIC और AT90 के लिए कोडांतरक से परिचित हूं)। उसका संक्रमण कार्य कैसे बनाया गया है?

संक्रमण बिना शर्त हैं (बस अगले पते पर जा रहे हैं, एक सबप्रोग्राम में जा रहे हैं, इसे बाहर निकाल रहे हैं) और सशर्त (झंडे की स्थिति के आधार पर)।

मैं सभी जिम्मेदारी के साथ घोषणा करता हूं - असेंबलर में संक्रमण के संचालन के बिना करना असंभव है! कोडांतरक में किसी भी कार्यक्रम बस उन्हें चकाचौंध! हालांकि, कोई भी मेरे साथ यहां बहस नहीं करता है, मुझे लगता है, नहीं करेगा।

परिणाम

क्या कहा जा सकता है? माइक्रोप्रोसेसर स्तर पर, संक्रमण संचालन बहुत सक्रिय रूप से उपयोग किया जाता है। एक वास्तविक कार्यक्रम लिखना लगभग असंभव है जो उनका उपयोग नहीं करता है (शायद यह किया जा सकता है, लेकिन यह एक सुपर-मेगा-विकृति होगी और निश्चित रूप से वास्तविक कार्यक्रम नहीं है!)। कोई भी इसके साथ बहस नहीं करेगा।

लेकिन, फिर, उच्च स्तर की भाषाओं में - माइक्रोकंट्रोलर्स के लिए सी पर ध्यान केंद्रित करना - गोटो ऑपरेटर अचानक एहसान से बाहर क्यों है? ..?

एल्गोरिदम के बारे में थोड़ा सा

अब एक मुश्किल एल्गोरिदम को देखते हैं। मुझे नहीं पता कि यह किस तरह की बकवास है - लेकिन इसे लागू करने की आवश्यकता है। हम मानते हैं कि यह टीके है।

यहाँ A, B, C, D, E कुछ ऑपरेशन हैं , फ़ंक्शन कॉल नहीं! यह संभव है कि वे बहुत सारे स्थानीय चर का उपयोग करें। और संभव है कि वे अपना राज्य बदल लें। यही है, इस मामले में हम कॉलिंग फ़ंक्शन के बारे में बात नहीं कर रहे हैं - कुछ क्रियाएं विस्तृत नहीं होंगी।

यह गोटो के साथ कैसा दिखता है:

if (a) { A; goto L3; } L1: if (b) { L2: B; L3: C; goto L1; } else if (!c) { D; goto L2; } E; 

बहुत संक्षिप्त और पठनीय। लेकिन - यह असंभव है! चलिए बिना गोटो के कोशिश करते हैं:

 char bf1, bf2, bf3; if (a) { A; bf1 = 1; } else bf1 = 0; bf2 = 0; do { do { if (bf3 || b) bf3 = 1; else bf3 = 0; if (bf3 || bf2) B; if (bf3 || bf1 || bf2) { C; bf1 = 0; bf2 = 1; } if (!bf3) { if (!c) { D; bf3 = 1; } else { bf3 = 0; bf2 = 0; } } } while (bf3); } while (bf2); E; 

क्या आप दूसरी लिस्टिंग के तर्क से कुछ समझते हैं?
दोनों लिस्टिंग की तुलना करें:

• मैंने दूसरी की तुलना में पहली सूची में 5 गुना कम समय बिताया।
• गोटो के साथ लिस्टिंग कम से कम 2 गुना कम है।
• गोटो के साथ लिस्टिंग को सी में सबसे कम प्रशिक्षण वाले किसी के द्वारा समझा जाएगा। मैंने इसे संभव के रूप में सुलभ और स्पष्ट बनाने की कोशिश की - और वैसे भी, इसमें देरी करने में लंबा समय लगता है।
• पहला विकल्प डिबग करने में कितना समय लगेगा और दूसरा डीबग करने में कितना समय लगेगा?
• और सामान्य तौर पर, अगर हम तैयार एल्गोरिथम को समस्या का एक बयान मानते हैं, तो पहली सूची 100% सही है। दूसरे के बारे में, मुझे अभी भी बहुत यकीन नहीं है ... कम से कम स्थितियों और झंडे की जाँच के क्रम में।
• पहले और दूसरे लिस्टिंग के लिए परिणामी विधानसभा कोड की तुलना करें।

लेकिन दूसरी लिस्टिंग में कोई गोटो नहीं है!

मुझे भी इस एल्गोरिथम की पेशकश की गई थी ताकि कुछ इस तरह से लागू किया जा सके:


if a
A
C

while b or not c
if not b
D
B
C

E



यह सुंदर लग रहा है, है ना? कॉपी-पास्ट क्यों नहीं बनाया जाता, अतिरिक्त जांचों को हवा क्यों नहीं दी जाती, क्यों ... सब कुछ आप चाहते हैं सिवाय गोटो के !!!

ठीक है, ठीक है, जीवन में ऐसे एल्गोरिदम लगभग कभी नहीं पाए जाते हैं। जीवन के बारे में बेहतर बात करते हैं।

असली कार्यक्रमों में गोटो

अपने 20 से अधिक वर्षों के अनुभव के लिए, मैंने कई हार्डवेयर प्लेटफार्मों और एक दर्जन प्रोग्रामिंग भाषाओं के माध्यम से जाना, एक बड़े ActiveHDL सॉफ्टवेयर उत्पाद को लिखने में भाग लिया, एक वाणिज्यिक डेटाबेस बनाया और ओलंपिक खेलों में उपयोग किए जाने वाले डिबगिंग उपकरणों के लिए कई छोटे कार्यक्रम बनाए, और इसके लिए डिवाइस भी बनाए। ओलंपिक (सटीक होने के लिए पहले से ही कई ओलंपिक)। संक्षेप में, कुछ मैं प्रोग्रामिंग में फेरबदल कर रहा हूं। और, हाँ, मैं भूल गया था - मैंने KHNURE से मानद डिप्लोमा के साथ स्नातक किया है - अर्थात् , सिद्धांत रूप में, मैं भी बकवास करता हूं।

इसलिए, मेरे बाद के विचार और स्थितियां ... आइए हम केवल यह कहते हैं कि मेरा उन पर नैतिक अधिकार है।

गोटो का प्रभावशाली उपयोग

सी में, कई ऑपरेटर हैं जो वास्तव में तुच्छ गोटो हैं - सशर्त या बिना शर्त। ये सभी प्रकार के हैं (...), जबकि (...) {...}, do {...} जबकि (...) लूप हैं। यह संख्यात्मक चर स्विच (...) {केस ... केस ...} का विश्लेषण है। ब्रेक और जारी लूप में ये समान रुकावट / कूद कथन हैं। अंत में, ये फंक्शनल () फ़ंक्शंस पर कॉल करते हैं और उनसे बाहर निकलते हैं।

इन गोटो को "कानूनी" माना जाता है - गोटो ही अवैध क्यों है?

क्या गोटो का आरोप है

वे उसे अपठनीय, खराब रूप से अनुकूलित होने का आरोप लगाते हैं, और त्रुटियां दिखाई दे सकती हैं। यह व्यावहारिक विपक्ष के बारे में है। और सैद्धांतिक लोग केवल बुरे और अनपढ़ हैं, और यह बात है!

कोड अपठनीयता और खराब ऑप्टिमिज़ेबिलिटी के बारे में, उपरोक्त लिस्टिंग पर एक और नज़र डालें।
त्रुटियों की संभावना के लिए - मैं सहमत हूं, इस कोड को इस तथ्य के कारण कुछ अधिक जटिल माना जाता है कि हम ऊपर से नीचे तक लिस्टिंग पढ़ने के लिए उपयोग किए जाते हैं। लेकिन वह सब है! लेकिन क्या, C के अन्य साधन सुरक्षित हैं और कोड में त्रुटियाँ पैदा नहीं कर सकते? हां, कम से कम टाइप रूपांतरण करें, पॉइंटर्स के साथ काम करें। वहाँ कुछ भी नहीं करने के लिए - पेंच करने के लिए!

क्या आपको नहीं लगता कि चाकू बहुत खतरनाक चीज है? लेकिन रसोई में किसी कारण से हम इसका उपयोग करते हैं। और 220 वोल्ट - हॉरर, कितना खतरनाक है! लेकिन अगर आप इसे समझदारी से इस्तेमाल करते हैं, तो आप जी सकते हैं।

गोटो के लिए भी यही होता है। आपको इसे बुद्धिमानी से उपयोग करने की आवश्यकता है - और फिर कोड सही ढंग से काम करेगा।

और सैद्धांतिक तर्कों के बारे में - यह, मुझे माफ करना, स्वाद के बारे में एक बहस है। क्या आप हंगेरियन नोटेशन का उपयोग करते हैं? मैं - नहीं, मैं उसे खड़ा नहीं कर सकता! लेकिन मैं यह नहीं कह रहा हूँ कि वह इस वजह से बुरी है! व्यक्तिगत रूप से, मेरा मानना ​​है कि एक चर को एक सिमेंटिक लोड करना चाहिए - यह क्यों बनाया गया है। लेकिन मैं इस नामकरण सम्मेलन का उपयोग करने से अन्य लोगों को प्रतिबंधित नहीं करूंगा!

या ऐसे सौंदर्यवादी हैं जो मानते हैं कि एक = ++ i अनपढ़ है, आपको i = i + 1 लिखना होगा; a = i और अब क्या, इस पर भी प्रतिबंध लगाने के लिए?

हैंडलिंग में त्रुटि

कुछ बाहरी डिवाइस से इनपुट पैकेट की प्रोसेसिंग करें:

 pack = receive_byte (); switch (pack) { case 'A': for (f = 0; f < 10; ++f) { … if (timeout) goto Leave; … } break; case 'B': … } Leave: … 

हमें पैकेज हेडर मिला। हम का विश्लेषण किया। हाँ, पैकेज 'ए' - इसका मतलब है कि हमें 10 बार कुछ करने की आवश्यकता है। हम इस साइट के संचालन समय को नियंत्रित करना नहीं भूलते हैं - क्या होगा यदि दूसरा पक्ष जमी है? हाँ, यह अभी भी लटका हुआ है - टाइमआउट स्थिति ने काम किया - फिर हम बाहर जाते हैं - लूप से, स्विच से।

एक ही चीज को सभी प्रकार के झंडे के साथ किया जा सकता है - लेकिन यह धीमी गति से काम करेगा, साथ ही यह इस तरह की दुर्लभ मेमोरी सेल लेगा। क्या यह इसके लायक है?

यह एक साधारण मामला है। लेकिन Rece_byte () प्रसंस्करण टाइमआउट के साथ एक मैक्रो फ़ंक्शन भी हो सकता है। और ऐसे तीखे निकास भी होंगे।

यह वास्तव में मामला है जहां मैं सक्रिय रूप से गोटो का उपयोग करता हूं। इसने मुझे बाहरी उपकरणों, UART, USB, आदि की समस्याओं की स्थिति में फंसने की अनुमति नहीं दी।

नेस्टेड लूप आउट से बाहर निकलें

नीचे कार्यक्रम पर एक नज़र डालें:

 char a, b, c; for (a = 0; a < 10; ++a) { for (b = 0; b < a; ++b) { if (!c) goto Leave; } for (b = 10; b < 15; ++b) { d (); } } Leave: e (); 

क्या हो रहा है - समझे? एक नेस्टेड लूप है। यदि कुछ स्थिति हुई है, तो हम सभी बाद के प्रसंस्करण को छोड़ देते हैं।

झंडे वाला यह कोड अलग दिखता है:

 char a, b, c, f1; f1 = 1; for (a = 0; a < 10 && f1; ++a) { for (b = 0; b < a && f1; ++b) { if (!c) f1 = 0; } if (f1) { for (b = 10; b < 15; ++b) { d (); } } } e (); 

इस मामले में क्या हुआ? प्रत्येक पुनरावृत्ति पर, अब हम ध्वज की जाँच करते हैं। इसे और जांचना न भूलें। ये ट्राइफल्स हैं, अगर कुछ पुनरावृत्तियों हैं और हम पीसी में "आयाम रहित" मेमोरी के बारे में बात कर रहे हैं। और जब कार्यक्रम माइक्रोकंट्रोलर के लिए लिखा जाता है - यह सब आवश्यक हो जाता है।

वैसे, इस संबंध में, कुछ भाषाओं में (अगर मैं गलत नहीं हूं, तो जावा में) फॉर्म ब्रेक लीव के एक लेबल द्वारा लूप से बाहर निकलने का अवसर है। वही गोटो, वैसे!

मैं स्विच (...) {केस ...} में प्रसंस्करण के साथ सटीक एक ही उदाहरण दे सकता हूं। एक अलग संरचना के आने वाले पैकेट को संसाधित करते समय मैं अक्सर इसका सामना करता हूं।

ऑटो कोड जनरेशन

क्या आप स्वचालित प्रोग्रामिंग से परिचित हैं? या कोई अन्य स्वचालित कोड पीढ़ी? लेक्सिकल हैंडलर के रचनाकारों का कहना है (भारी बढ़ावा का उपयोग किए बिना :: आत्मा)। ये सभी प्रोग्राम एक कोड बनाते हैं जिसका उपयोग "ब्लैक बॉक्स" के रूप में किया जा सकता है - आपको इस बात की परवाह नहीं है कि अंदर क्या है; यह आपके लिए महत्वपूर्ण है कि वह क्या करता है। और अंदर गोटो का बहुत उपयोग किया जाता है, अक्सर ...

एक जगह से बाहर निकलें

C में, आपको कभी-कभी कुछ लिखना होगा:

 int f (…) { … if (a) { c = 15; return 10; } … if (b) { c = 15; return 10; } …  = 10; return 5; } 

यह कोड इस तरह अधिक सटीक लगेगा:

 int f (…) { … if (a) goto Exit; … if (b) goto Exit; …  = 10; return 5; Exit: c = 15; return 10; } 

क्या विचार स्पष्ट है? कभी-कभी बाहर निकलने पर आपको कुछ करने की जरूरत होती है। कभी-कभी बहुत कुछ करना है। और फिर गोटो बहुत मदद करता है। मेरे पास भी ऐसे उदाहरण हैं।
ऐसा लगता है कि सब कुछ सूचीबद्ध है, अब आप संक्षेप में बता सकते हैं ...

परिणाम

यह मेरी बात है! और वह मेरे लिए उचित है। शायद - आपके लिए, लेकिन मैं आपको इसका पालन करने के लिए मजबूर नहीं करूंगा!

तो, मेरे लिए यह स्पष्ट है कि गोटो कुछ समस्याओं को इष्टतम और बेहतर तरीके से हल करने में मदद करता है।
और कभी-कभी इसके विपरीत - गोटो बहुत सारी समस्याएं पैदा कर सकते हैं।

UPD : टिप्पणियों का एक पहाड़ पढ़ने के बाद, मैंने अपने लिए गोटो और नकारात्मक लोगों के उपयोग के सकारात्मक पहलुओं पर प्रकाश डाला।

गोटो का उपयोग करने के नियम :

• कई नेस्टेड छोरों और स्विच ... केस में से सबसे इष्टतम तरीका (यानी, लिस्टिंग और परिणाम कोड)
• सी: त्रुटियों को संभालने के लिए सबसे किफायती (सूची और परिणाम कोड द्वारा) तरीका
• व्यक्तिगत मामलों में, एल्गोरिथ्म का सबसे इष्टतम निर्माण
• स्मृति और चातुर्य को सावधानीपूर्वक उपयोग करने से बचाता है, जो कभी-कभी सबसे महत्वपूर्ण होता है

गोटो का उपयोग करने की विपक्ष :

• कोड अपरिचितता
• सूची को ऊपर से नीचे पढ़ने के अनुक्रम का उल्लंघन और कोड में एक मानकीकृत ब्लॉक ट्रैवर्सल ( इस अर्थ में कि ब्लॉक के केंद्र पर जाना संभव है, साथ ही साथ इससे बाहर निकलना )
• कोड अनुकूलन प्रक्रिया के कंपाइलर (और कभी-कभी असंभव) की जटिलता
• सूक्ष्म कोड त्रुटियों को बनाने की संभावना बढ़ रही है

पेशेवरों / विपक्ष को और कौन बताएगा? यदि वे उचित हैं तो मैं लिखूंगा

मैं एक बार फिर ध्यान देता हूं : मुझे हर जगह पाने के लिए आग्रह नहीं है ! लेकिन कुछ मामलों में, यह आपको एल्गोरिथ्म को अन्य सभी साधनों की तुलना में अधिक कुशलता से लागू करने की अनुमति देता है।