C या C ++ में अच्छे गोटो के उदाहरण [बंद]

Question

इस सूत्र में, हम gotoC या C ++ के अच्छे उपयोग के उदाहरणों को देखते हैं । यह एक उत्तर से प्रेरित है जिसे लोगों ने वोट दिया क्योंकि उन्हें लगा कि मैं मजाक कर रहा हूं।

सारांश (इरादे को और अधिक स्पष्ट करने के लिए मूल से लेबल बदल गया):

infinite_loop:

    // code goes here

goto infinite_loop;

यह विकल्पों से बेहतर क्यों है:

• यह विशिष्ट है। gotoवह भाषा निर्माण है जो बिना शर्त शाखा का कारण बनता है। अल्टरनेटिव हमेशा-सही स्थिति के साथ, विकल्प सशर्त शाखाओं का समर्थन करने वाली संरचनाओं का उपयोग करने पर निर्भर करते हैं।
• लेबल अतिरिक्त टिप्पणियों के बिना इरादे का दस्तावेजीकरण करता है।
• पाठक को शुरुआती breakएस के लिए हस्तक्षेप कोड को स्कैन करने की आवश्यकता नहीं है (हालांकि यह अभी भी एक अप्रकाशित हैकर के लिए continueजल्दी से अनुकरण करने के लिए संभव है goto)।

नियम:

• प्रोटोपेंड करें कि गोटोफॉब्स को जीत नहीं मिली। यह समझा जाता है कि ऊपर वास्तविक कोड में इस्तेमाल नहीं किया जा सकता क्योंकि यह स्थापित मुहावरों के खिलाफ है।
• मान लें कि हम सभी ने 'गोटो को हानिकारक माना है' के बारे में सुना है और जानते हैं कि गोटो का इस्तेमाल स्पेगेटी कोड लिखने के लिए किया जा सकता है।
• यदि आप एक उदाहरण से असहमत हैं, तो अकेले तकनीकी योग्यता पर इसकी आलोचना करें ('क्योंकि लोगों को गोटो पसंद नहीं है' तकनीकी कारण नहीं है)।

आइए देखें कि क्या हम इस तरह के बड़े होने के बारे में बात कर सकते हैं।

संपादित करें

यह प्रश्न अब समाप्त हो रहा है। इसने कुछ उच्च गुणवत्ता वाले उत्तर उत्पन्न किए। सभी के लिए धन्यवाद, खासकर उन लोगों के लिए जिन्होंने मेरे छोटे लूप उदाहरण को गंभीरता से लिया। ज्यादातर संशयवाद ब्लॉक स्कोप की कमी से चिंतित थे। जैसा कि @quinmars ने एक टिप्पणी में बताया है, आप हमेशा लूप बॉडी के चारों ओर ब्रेसिज़ लगा सकते हैं। मुझे लगता है कि पारित करने में ध्यान दें for(;;)और while(true)आप मुफ्त या तो के लिए ब्रेसिज़ देना नहीं है (और उन्हें छोड़ते हुए परेशान कीड़े पैदा कर सकता है)। वैसे भी, मैं इस तिपहिया पर अपने मस्तिष्क की शक्ति का कोई भी अधिक हिस्सा बर्बाद नहीं करूंगा - मैं हानिरहित और मुहावरे के साथ रह सकता हूं for(;;)और while(true)(साथ ही अगर मैं अपनी नौकरी रखना चाहता हूं)।

अन्य प्रतिक्रियाओं को ध्यान में रखते हुए, मैं देखता हूं कि बहुत से लोग एक gotoऐसी चीज को देखते हैं जिसे आपको हमेशा दूसरे तरीके से लिखना पड़ता है। बेशक, आप gotoएक लूप, एक अतिरिक्त ध्वज, नेस्टेड ifएस के ढेर या जो भी हो, को शुरू करने से बच सकते हैं , लेकिन क्यों नहीं माना जाता है कि क्या gotoशायद नौकरी के लिए सबसे अच्छा उपकरण है? एक और तरीका रखो, अपने इच्छित उद्देश्य के लिए एक अंतर्निहित भाषा सुविधा का उपयोग करने से बचने के लिए लोग कितने कुरूपता के लिए तैयार हैं? मेरा मानना ​​है कि झंडा जोड़ने पर भी कीमत चुकानी पड़ती है। मुझे समस्या या समाधान डोमेन में चीजों का प्रतिनिधित्व करने के लिए मेरे चर पसंद हैं। 'पूरी तरह से बचने के लिए goto' यह कटौती नहीं करता है।

मैं पहले जवाब को स्वीकार करूंगा जिसने सी ब्लॉक को क्लीनअप ब्लॉक करने के लिए पैटर्न दिया था। IMO, यह gotoपोस्ट किए गए सभी उत्तरों में से सबसे मजबूत मामला है, निश्चित रूप से यदि आप इसे गर्भनिरोधकों द्वारा मापते हैं तो एक हैटर को इससे बचने के लिए गुजरना पड़ता है।

Comments

मुझे समझ नहीं आता कि प्रोजेक्ट के शामिल फ़ाइल के शीर्ष पर gotophobes सिर्फ "#define goto report_to_your_supervisor_for_re_education_through_labour" लिखना अनिवार्य नहीं है। यदि यह हमेशा गलत है, तो इसे असंभव बना दें। अन्यथा, यह कभी-कभी ही सही होता है ...

— स्टीव जेसप

"वास्तविक कोड में उपयोग नहीं किया जा सकता है"? मैं इसे "वास्तविक" कोड में उपयोग करता हूं किसी भी समय यह नौकरी के लिए सबसे अच्छा उपकरण है। "स्थापित मुहावरे" "अंधे कुत्तेवाद" के लिए एक अच्छी व्यंजना है।

— दान मोल्डिंग

मैं मानता हूं कि "गोटो" उपयोगी हो सकता है (नीचे महान उदाहरण हैं), लेकिन मैं आपके विशिष्ट उदाहरण से असहमत हूं। एक पंक्ति जो "गोटो अनंत_लूप" कहती है, इसका मतलब है "कोड के उस हिस्से पर जाएं जहां हम हमेशा के लिए लूपिंग शुरू करने जा रहे हैं," जैसा कि "इनिशियलाइज़ (); सेट_थिंग्स_अप (); गोटो अनंत लूप;" जब आप वास्तव में व्यक्त करने का मतलब है "हम पहले से ही कर रहे पाश का अगला पुनरावृत्ति शुरू करते हैं," जो पूरी तरह से अलग है। यदि आप लूप की कोशिश कर रहे हैं, और आपकी भाषा में विशेष रूप से लूपिंग के लिए डिज़ाइन किए गए निर्माण हैं, तो स्पष्टता के लिए उन का उपयोग करें। जबकि (सच) {foo ()} बहुत असंदिग्ध है।

— जोश

आपके उदाहरण के लिए एक बड़ा नकारात्मक पहलू यह है कि यह स्पष्ट नहीं है कि कोड में कौन से ओहटर स्थान इस लेबल पर कूदने का निर्णय ले सकते हैं। एक "सामान्य" अनंत लूप ( for (;;)) में कोई आश्चर्यजनक प्रवेश बिंदु नहीं है।

— jalf

@ György: हाँ, लेकिन यह एक प्रवेश बिंदु नहीं है।

— जलफ

Answer 1

Heres एक ट्रिक जो मैंने लोगों को इस्तेमाल करने के बारे में सुना है। मैंने इसे जंगली में कभी नहीं देखा है। और यह केवल C पर लागू होता है क्योंकि C ++ में RAI को यह अधिक मुहावरेदार तरीके से करना है।

void foo()
{
    if (!doA())
        goto exit;
    if (!doB())
        goto cleanupA;
    if (!doC())
        goto cleanupB;

    /* everything has succeeded */
    return;

cleanupB:
    undoB();
cleanupA:
    undoA();
exit:
    return;
}

Comments

इसमें गलत क्या है? (इस तथ्य के अलावा कि टिप्पणियां नई समझ में नहीं आती हैं) शून्य फू () {if (doA ()) {if (doB ()) {if (doC ()) {/ * सब कुछ सफल * / वापसी; } undoB (); } पूर्ववत करें (); } वापसी; }

— आर्टिलियस

अतिरिक्त ब्लॉक अनावश्यक इंडेंटेशन का कारण बनते हैं जो पढ़ना मुश्किल है। यह भी काम नहीं करता है अगर एक स्थिति लूप के अंदर है।

— एडम रोसेनफील्ड

आप इस तरह के कोड को अधिकांश निम्न स्तर की यूनिक्स चीजों में देख सकते हैं (जैसे कि लिनक्स कर्नेल, उदाहरण के लिए)। C में, IMHO को पुनर्प्राप्त करने में त्रुटि के लिए सबसे अच्छा मुहावरा है।

— बजे डेविड कूर्नपेउ

जैसा कि उल्लेख किया गया है, लिनक्स कर्नेल हर समय इस शैली का उपयोग करता है ।

— सीजरबी

न केवल लिनक्स कर्नेल microsoft से विंडोज ड्राइवर के नमूनों पर एक नज़र डालते हैं और आपको एक ही पैटर्न मिलेगा। सामान्य तौर पर यह अपवादों को संभालने का एक तरीका है और बहुत उपयोगी है :)। मैं आमतौर पर केवल 1 लेबल और कुछ मामलों में पसंद करता हूं। 99% मामलों में 3 से बचा जा सकता है।

— इल्या

Answer 2

C में GOTO की क्लासिक आवश्यकता इस प्रकार है

for ...
  for ...
    if(breakout_condition) 
      goto final;

final:

बिना गोटो के नेस्टेड लूप्स को तोड़ने का कोई सीधा तरीका नहीं है।

Comments

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

— दारा बेकन

मैं निश्चित रूप से डेरियस से सहमत हूं - इसे एक समारोह में रिफ्लेक्टर करें और इसके बजाय लौटें!

— मेटाओ

@metao: बज़्ने स्ट्रॉस्ट्रुप असहमत। उनकी C ++ प्रोग्रामिंग लैंग्वेज बुक पर, यह बिल्कुल गोटो के "अच्छे उपयोग" का उदाहरण है।

— पियरसबल

@ अदम रोसेनफील्ड: गोजो के साथ पूरी समस्या , दिक्जस्त्र द्वारा हाइलाइट की गई, यह है कि संरचित प्रोग्रामिंग अधिक समझदार निर्माण प्रदान करती है। गोटो से बचने के लिए कोड को पढ़ने में कठिन बनाना यह साबित करता है कि लेखक उस निबंध को समझने में विफल रहा ...

— स्टीव जेसप

@ स्तेव जेसोप: न केवल लोगों ने निबंध को गलत समझा है, अधिकांश "कोई भी नहीं जाता" कृषक उस ऐतिहासिक संदर्भ को नहीं समझते हैं जिसमें यह लिखा गया था।

— JUST MY सही OPINION

Answer 3

यहाँ मेरा गैर-मूर्खतापूर्ण उदाहरण है, (Stevens APITUE से) यूनिक्स सिस्टम कॉल के लिए जिसे सिग्नल द्वारा बाधित किया जा सकता है।

restart:
    if (system_call() == -1) {
        if (errno == EINTR) goto restart;

        // handle real errors
    }

विकल्प एक पतित पाश है। यह संस्करण अंग्रेजी की तरह पढ़ता है "यदि सिस्टम कॉल एक सिग्नल द्वारा बाधित किया गया था, तो इसे पुनरारंभ करें"।

Comments

इस तरह से उदाहरण के लिए प्रयोग किया जाता है लिनक्स शेड्यूलर के पास एक गोटो है, लेकिन मैं कहूंगा कि बहुत कम मामले हैं जहां बैकवर्ड गोटो स्वीकार्य हैं और सामान्य रूप से बचा जाना चाहिए।

— इल्या

@Amarghosh, continueसिर्फ gotoएक मुखौटा में है।

— १२:३१ पर

@jball ... हम्म .. तर्क के लिए, हाँ; आप गोटो और स्पेगेटी कोड के साथ जारी रखने के साथ अच्छा पठनीय कोड बना सकते हैं .. अंततः यह उस व्यक्ति पर निर्भर करता है जो कोड लिखता है। मुद्दा यह है कि जारी रखने के मुकाबले गोटो के साथ खो जाना आसान है। और newbies आम तौर पर हर समस्या के लिए मिलने वाले पहले हथौड़ा का उपयोग करते हैं।

— अमरघोष

@ अमरघोष आपका 'बेहतर' कोड मूल के बराबर भी नहीं है - यह सफलता के मामले में हमेशा के लिए खत्म हो जाता है।

— fizzer

@ फ़िज़र्स ओपसी .. इसे else breakसमतुल्य बनाने के लिए दो एस (प्रत्येक के लिए एक) की आवश्यकता है .. मैं क्या कह सकता हूं ... gotoया नहीं, आपका कोड केवल उतना ही अच्छा है :(

— अमरघोष

Answer 4

यदि डफ के उपकरण को गोटो की जरूरत नहीं है, तो आपको भी नहीं चाहिए! ;)

void dsend(int count) {
    int n;
    if (!count) return;
    n = (count + 7) / 8;
    switch (count % 8) {
      case 0: do { puts("case 0");
      case 7:      puts("case 7");
      case 6:      puts("case 6");
      case 5:      puts("case 5");
      case 4:      puts("case 4");
      case 3:      puts("case 3");
      case 2:      puts("case 2");
      case 1:      puts("case 1");
                 } while (--n > 0);
    }
}

विकिपीडिया प्रविष्टि से ऊपर कोड ।

Comments

लोगों को बुलाओ, अगर आप नीचे जा रहे हैं, तो एक छोटी टिप्पणी क्यों महान होगी। :)

— मिच गेहूं

यह एक तार्किक गिरावट का उदाहरण है जिसे "प्राधिकरण की अपील" के रूप में भी जाना जाता है। इसे विकिपीडिया पर देखें।

— मार्कस ग्रिप

हास्य अक्सर यहाँ अप्राप्य है ...

— स्टीवन ए। लोव

क्या डफ का उपकरण बीयर बनाता है?

— स्टीवन ए। लोवे

यह एक समय में 8 बना सकता है ;-)

— जैस्पर बेकर्स

Answer 5

नुथ ने एक पेपर लिखा है "GOTO स्टेटमेंट्स के साथ स्ट्रक्चर्ड प्रोग्रामिंग", आप इसे यहाँ से प्राप्त कर सकते हैं । आपको वहां कई उदाहरण मिलेंगे।

Comments

यह कागज गहरा दिखता है। हालांकि मैं इसे पढ़ूंगा। धन्यवाद

— २२:०६ पर fizzer

यह पेपर इतना पुराना है, यह मज़ेदार भी नहीं है। नथ की मान्यताओं का अब कोई महत्व नहीं है।

— कोनराड रुडोल्फ

कौन सी धारणाएँ? उनके उदाहरण सी के रूप में एक प्रक्रियात्मक भाषा के लिए आज वास्तविक हैं (वह उन्हें कुछ छद्म कोड में देता है) जैसा कि वे उस समय थे।

— zvrba

im ने आपको निराश नहीं किया :: आप इसे प्राप्त करने के लिए 'यहाँ' प्राप्त कर सकते हैं, मेरे लिए यह दंड असहनीय होगा कि आप ऐसा न करें!

— 13

Answer 6

बहुत ही आम।

do_stuff(thingy) {
    lock(thingy);

    foo;
    if (foo failed) {
        status = -EFOO;
        goto OUT;
    }

    bar;
    if (bar failed) {
        status = -EBAR;
        goto OUT;
    }

    do_stuff_to(thingy);

OUT:
    unlock(thingy);
    return status;
}

एकमात्र ऐसा मामला जो मैं कभी-कभी उपयोग करता हूं gotoवह आगे की ओर कूदने के लिए होता है, आमतौर पर ब्लॉकों से बाहर, और कभी भी ब्लॉक में नहीं। यह do{}while(0)और अन्य निर्माणों के दुरुपयोग से बचा जाता है , जो पठनीय, संरचित कोड को बनाए रखते हुए घोंसले के शिकार को बढ़ाता है।

Comments

मुझे लगता है कि यह त्रुटि से निपटने का टाइप सी है। मैं इसे अच्छी तरह से, बेहतर पठनीय किसी अन्य तरीके से नहीं देख सकता हूं

— फ्रेडरिक

क्यों नहीं ... do_stuff(thingy) { RAIILockerObject(thingy); ..... /* -->*/ } /* <---*/ :)

— Петър Петров

@ ПетърПетров C ++ एक पैटर्न सी में कोई अनुरूप है कि यही कारण है कि

— ephemient

या C ++ की तुलना में और भी अधिक संरचित भाषा में, try { lock();..code.. } finally { unlock(); }लेकिन हाँ C का कोई समकक्ष नहीं है।

— ब्लाइंडी

Answer 7

मेरे पास सामान्य तौर पर गोटो के खिलाफ कुछ भी नहीं है, लेकिन मैं कई कारणों के बारे में सोच सकता हूं कि आप उन्हें एक लूप के लिए उपयोग क्यों नहीं करना चाहेंगे जैसे आपने उल्लेख किया है:

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

Comments

is inf_loop: {/ * लूप बॉडी * /} गोटो inf_loop; बेहतर है? :)

— क्विनमार्स

अंक 1-4 ब्रेसिज़ के बिना भी इस उदाहरण के लिए संदिग्ध हैं । 1 यह एक अनंत लूप है। 2 पता करने के लिए बहुत अस्पष्ट। 3 एनक्लोजिंग स्कोप में एक ही नाम के वेरिएबल को छिपाने की कोशिश करना खराब प्रैक्टिस है। 4. एक पिछड़े गोटो एक घोषणा को छोड़ नहीं सकते।

— फिजर

सभी अनंत छोरों के साथ 1-4, आपके पास आमतौर पर बीच में कुछ प्रकार की ब्रेक की स्थिति होती है। इसलिए वे लागू हैं। पुनः एक बेकाबू गोटो एक घोषणा को छोड़ नहीं सकता है ... सभी गोटो पीछे की ओर नहीं हैं ...

— ब्रायन आर। बॉडी

Answer 8

एक गोटो का उपयोग करने के लिए एक अच्छी जगह एक प्रक्रिया है जो कई बिंदुओं पर गर्भपात कर सकती है, जिनमें से प्रत्येक को सफाई के विभिन्न स्तरों की आवश्यकता होती है। Gotophobes हमेशा संरचित कोड और परीक्षणों की एक श्रृंखला के साथ गोटो को बदल सकता है, लेकिन मुझे लगता है कि यह अधिक सीधा है क्योंकि यह अत्यधिक खरोज को खत्म करता है:

अगर (OpenDataFile ())
  गोटो छोड़ दिया;

अगर (getDataFromFile ())
  गोटो क्लोजिलेएंडक्यूइट;

यदि (आवंटित करें)
  गोटो freeResourcesAndQuit;

// यहाँ और काम करो…।

freeResourcesAndQuit:
   // मुफ्त संसाधन
बंद करें
   // बंद फाइल
छोड़ दिया:
   // छोड़ दिया!

Comments

मैं कार्यों का एक सेट के साथ इस जगह लेंगे: freeResourcesCloseFileQuit, closeFileQuit, और quit।

— RCIX

यदि आपने ये 3 अतिरिक्त कार्य बनाए हैं, तो आपको मुक्त / बंद किए जाने के लिए संसाधनों और फ़ाइलों को पॉइंटर्स / हैंडल पास करना होगा। आप शायद freeResourcesCloseFileQuit () कॉल closeFileQuit () बनाते हैं, जो बदले में कॉल छोड़ देंगे ()। अब आपके पास बनाए रखने के लिए 4 कसने वाले युग्मित कार्य हैं, और उनमें से 3 को संभवतः सबसे अधिक बार बुलाया जाएगा: ऊपर एकल फ़ंक्शन से। यदि आप गोटो से बचने पर जोर देते हैं, तो IMO, नेस्टेड अगर () ब्लॉक में कम ओवरहेड है और पढ़ने और बनाए रखने में आसान है। आप 3 अतिरिक्त कार्यों के साथ क्या हासिल करते हैं?

— एडम लिस

Answer 9

@ fizzer.myopenid.com: आपका पोस्ट किया गया कोड स्निपेट निम्न के बराबर है:

    while (system_call() == -1)
    {
        if (errno != EINTR)
        {
            // handle real errors

            break;
        }
    }

मैं निश्चित रूप से इस फॉर्म को पसंद करता हूं।

Comments

ठीक है, मुझे पता है कि ब्रेक स्टेटमेंट गोटो का एक और अधिक स्वीकार्य रूप है ..

— मिच गेहूं

मेरी नजर में, यह भ्रामक है। यह एक लूप है जिसे आप सामान्य निष्पादन पथ में प्रवेश करने की उम्मीद नहीं करते हैं, इसलिए तर्क पीछे की ओर लगता है। राय का विषय, हालांकि।

— fizzer

पीछे की ओर? यह शुरू होता है, यह जारी रहता है, इसके माध्यम से गिरता है। मुझे लगता है कि यह रूप स्पष्ट रूप से इसके इरादों को बताता है।

— मिच गेहूं

मैं यहाँ फ़िज़र्स से सहमत होना चाहता हूँ कि गोटो हालत के मूल्य के अनुसार एक स्पष्ट उम्मीद प्रदान करता है।

— मार्कस ग्रिप

किस तरह से इस स्निपेट को फिजर्स की तुलना में पढ़ना आसान है।

— एरिक्कलेन 18

Answer 10

भले ही मैं समय के साथ इस पैटर्न से नफरत करने के लिए बढ़ गया हूं, यह COM प्रोग्रामिंग में दानेदार है।

#define IfFailGo(x) {hr = (x); if (FAILED(hr)) goto Error}
...
HRESULT SomeMethod(IFoo* pFoo) {
  HRESULT hr = S_OK;
  IfFailGo( pFoo->PerformAction() );
  IfFailGo( pFoo->SomeOtherAction() );
Error:
  return hr;
}

Answer 11

यहाँ एक अच्छे गोटो का एक उदाहरण दिया गया है:

// No Code

Comments

एर, कोई गोटो? (मजाकिया

— अंदाज

यह वास्तव में उपयोगी नहीं है

— जोसफ

मुझे लगा कि यह मजाकिया था। बहुत बढ़िया। +1

— शानदार मिस्टर फॉक्स

@FlySwat FYI करें: इसे निम्न गुणवत्ता समीक्षा कतार में मिला। संपादन पर विचार करें।

— पॉल

Answer 12

मैंने देखा है कि गोटो का उपयोग सही तरीके से किया जाता है लेकिन स्थितियां सामान्य रूप से बदसूरत हैं। यह केवल तब होता है जब gotoस्वयं का उपयोग मूल से बहुत कम खराब होता है। @ जॉनोथन हॉलैंड की कविता है कि आप संस्करण कम स्पष्ट हैं। लोगों को स्थानीय चर से डर लगता है:

void foo()
{
    bool doAsuccess = doA();
    bool doBsuccess = doAsuccess && doB();
    bool doCsuccess = doBsuccess && doC();

    if (!doCsuccess)
    {
        if (doBsuccess)
            undoB();
        if (doAsuccess)
            undoA();
    }
}

और मैं इस तरह से छोरों को पसंद करता हूं लेकिन कुछ लोग पसंद करते हैं while(true)।

for (;;)
{
    //code goes here
}

Comments

कभी, कभी, कभी भी एक बूलियन मान की तुलना सही या गलत से करें। यह पहले से ही एक बूलियन है; बस "doBsuccess = doAsuccess && doB ();" का उपयोग करें और "if (doCsuccess) {}" के बजाय। यह सरल है और आपको चतुर प्रोग्रामर से बचाता है जो "# सच सच 0" जैसी चीजों को लिखते हैं क्योंकि, ठीक है, क्योंकि वे कर सकते हैं। यह आपको प्रोग्रामर्स से भी बचाता है जो इंट और बूल का मिश्रण करते हैं, और फिर किसी भी गैर-शून्य मान को सही मानते हैं।

— एडम लिस

धन्यवाद और बिंदु को == trueहटा दिया गया। यह वैसे भी मेरी वास्तविक शैली के करीब है। :)

— चार्ल्स बीट्टी

Answer 13

इस बारे में मेरी पकड़ यह है कि आप ब्लॉक स्कूपिंग खो देते हैं; यदि लूप कभी भी टूट जाता है, तो गोटो के बीच घोषित कोई भी स्थानीय चर लागू रहता है। (शायद आप मान रहे हैं कि लूप हमेशा के लिए चलता है; मुझे नहीं लगता है कि मूल प्रश्न लेखक पूछ रहा था, हालाँकि।)

स्कोपिंग की समस्या C ++ के साथ एक समस्या है, क्योंकि कुछ वस्तुओं को उनके डोर को उपयुक्त समय पर बुलाया जा सकता है।

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

if(!foo_init())
  goto bye;

if(!bar_init())
  goto foo_bye;

if(!xyzzy_init())
  goto bar_bye;

return TRUE;

bar_bye:
 bar_terminate();

foo_bye:
  foo_terminate();

bye:
  return FALSE;

Answer 14

मैं स्वयं गोटो का उपयोग नहीं करता, हालाँकि मैंने एक व्यक्ति के साथ एक बार काम किया था जो विशिष्ट मामलों में उनका उपयोग करेगा। अगर मुझे सही तरीके से याद है, तो उनका तर्क प्रदर्शन के मुद्दों के आसपास था - उनके पास विशिष्ट नियम भी थे कि कैसे । हमेशा एक ही फ़ंक्शन में, और लेबल हमेशा गोटो स्टेटमेंट को कम करता है।

Comments

अतिरिक्त डेटा: ध्यान दें कि आप फ़ंक्शन के बाहर जाने के लिए गोटो का उपयोग नहीं कर सकते हैं, और यह कि C ++ में, किसी गोटो के माध्यम से एक ऑब्जेक्ट निर्माण को बायपास करने के लिए मना किया जाता है

— 9

Answer 15

#include <stdio.h>
#include <string.h>

int main()
{
    char name[64];
    char url[80]; /*The final url name with http://www..com*/
    char *pName;
    int x;

    pName = name;

    INPUT:
    printf("\nWrite the name of a web page (Without www, http, .com) ");
    gets(name);

    for(x=0;x<=(strlen(name));x++)
        if(*(pName+0) == '\0' || *(pName+x) == ' ')
        {
            printf("Name blank or with spaces!");
            getch();
            system("cls");
            goto INPUT;
        }

    strcpy(url,"http://www.");
    strcat(url,name);
    strcat(url,".com");

    printf("%s",url);
    return(0);
}

Answer 16

@Greg:

अपना उदाहरण इस तरह से क्यों न करें:

void foo()
{
    if (doA())
    {    
        if (doB())
        {
          if (!doC())
          {
             UndoA();
             UndoB();
          }
        }
        else
        {
          UndoA();
        }
    }
    return;
}

Comments

यह इंडेंटेशन के अनावश्यक स्तर को जोड़ता है, जो वास्तव में बालों को प्राप्त कर सकता है यदि आपके पास बड़ी संख्या में संभावित विफलता मोड हैं।

— एडम रोसेनफील्ड

मैं किसी भी दिन गोटे पर इंडेंटेशन लूंगा।

— फ्लाईसवाट

इसके अलावा, यह कोड की अधिक पंक्तियां हैं, इनमें से किसी एक मामले में एक अनावश्यक फ़ंक्शन कॉल है और सही तरीके से doD जोड़ने के लिए कहीं अधिक कठिन है।

— पैट्रिक

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

— माइकल बूर

यह कोड सिर्फ चिल्ला रहा है "मेरे पास अगले कुछ हफ्तों में एक बग होगा" कोई व्यक्ति कुछ पूर्ववत करना भूल जाएगा। आपको एक ही जगह अपने सभी पूर्ववत की आवश्यकता है। यह मूल OO भाषाओं में "अंततः" जैसा है।

— इल्या