एक स्विच के अंदर से एक लूप से बाहर निकलने के लिए कैसे?

Question

मैं कुछ कोड लिख रहा हूँ जो इस तरह दिखता है:

while(true) {
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        break; // **HERE, I want to break out of the loop itself**
    }
}

क्या ऐसा करने का कोई सीधा तरीका है?

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

Comments

स्विच के बाद आपको सशर्त ब्रेक की आवश्यकता क्यों है? बस अपने समय को (सच्चे) से (ध्वज) के समय में बदलें ...

— ताल प्रेसमैन

@Dave_Jarvis मुझे लगता है कि यह एक सरलीकृत संस्करण है जो उसने यहाँ वर्णन करने के लिए रखा है कि वह क्या करने की कोशिश कर रहा था।

— एल्टरलाइफ़

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

— sbi

अगर लगता है कि धूम्रपान छोड़ने की सलाह मिलने पर जब आप जानना चाहते हैं कि निकटतम मेट्रो स्टेशन पर कैसे जाना है।

— माइकल क्रेलिन -

@ शेकर: ठीक है, अगर आप सभी धुएं के कारण आपके सामने मेट्रो स्टेशन नहीं देख सकते हैं, तो यह सलाह शायद यह सब बुरा नहीं है। :)

— sbi

Answer 1

परिसर

भाषा या इच्छित कार्यक्षमता की परवाह किए बिना, निम्नलिखित कोड को बुरा रूप माना जाना चाहिए:

while( true ) {
}

तर्क का समर्थन करना

while( true )पाश, क्योंकि यह खराब फार्म है:

• थोड़ी देर के लूप के निहित अनुबंध को तोड़ता है।
  • जबकि लूप घोषणा स्पष्ट रूप से एकमात्र निकास स्थिति बताती है।
• लागू होता है कि यह हमेशा के लिए बंद हो जाता है।
  • लूप के भीतर कोड को समापन क्लॉज को समझने के लिए पढ़ा जाना चाहिए।
  • लूप्स जो हमेशा दोहराते हैं, उपयोगकर्ता को प्रोग्राम के भीतर से प्रोग्राम को समाप्त करने से रोकते हैं।
• अक्षम है।
  • "लूप" की जाँच सहित कई लूप टर्मिनेशन शर्तें हैं।
• कीड़ों से ग्रस्त है।
  • आसानी से यह निर्धारित नहीं किया जा सकता है कि प्रत्येक पुनरावृत्ति के लिए कोड को कहां रखा जाएगा।
• अनावश्यक रूप से जटिल कोड की ओर जाता है।
• स्वचालित स्रोत कोड विश्लेषण।
  • बग को खोजने के लिए, प्रोग्राम जटिलता विश्लेषण, सुरक्षा जांच, या स्वचालित रूप से कोड निष्पादन के बिना किसी अन्य स्रोत कोड व्यवहार को प्राप्त करना, प्रारंभिक ब्रेकिंग स्थिति निर्दिष्ट करना, एल्गोरिदम को उपयोगी आक्रमणकारियों को निर्धारित करने की अनुमति देता है, जिससे स्वचालित स्रोत कोड विश्लेषण मैट्रिक्स में सुधार होता है।
• अनंत छोरों।
  • अगर हर कोई हमेशा while(true)उन छोरों के लिए उपयोग करता है जो अनंत नहीं हैं, तो हम संक्षिप्त रूप से संवाद करने की क्षमता खो देते हैं जब छोरों की वास्तव में कोई समाप्ति स्थिति नहीं होती है। (तर्क से, यह पहले से ही हो चुका है, इसलिए बिंदु मूट है।)

"जाओ" के लिए वैकल्पिक

निम्नलिखित कोड बेहतर रूप है:

while( isValidState() ) {
  execute();
}

bool isValidState() {
  return msg->state != DONE;
}

लाभ

कोई झंडा नहीं। नहीं goto। कोई अपवाद नहीं। बदलने में आसान। पढ़ने में अासान। ठीक करना आसान है। इसके अतिरिक्त कोड:

1. लूप से ही लूप के वर्कलोड के ज्ञान को अलग करता है।
2. किसी को आसानी से कार्यक्षमता बढ़ाने के लिए कोड को बनाए रखने देता है।
3. एक स्थान पर कई समाप्ति शर्तों को असाइन करने की अनुमति देता है।
4. निष्पादित करने के लिए कोड से समाप्त समापन खंड को अलग करता है।
5. परमाणु ऊर्जा संयंत्रों के लिए सुरक्षित है। ;-)

दूसरा बिंदु महत्वपूर्ण है। यह जानने के बिना कि कोड कैसे काम करता है, अगर कोई मुझे मुख्य लूप बनाने के लिए कहे तो अन्य थ्रेड्स (या प्रक्रियाओं) में कुछ सीपीयू समय है, दो समाधान दिमाग में आते हैं:

विकल्प 1

आसानी से ठहराव डालें:

while( isValidState() ) {
  execute();
  sleep();
}

विकल्प 2

ओवरराइड निष्पादित करें:

void execute() {
  super->execute();
  sleep();
}

यह कोड एक एम्बेडेड के साथ लूप की तुलना में सरल (इस प्रकार पढ़ने में आसान) है switch। isValidStateविधि केवल यह निर्धारित करना चाहिए अगर पाश जारी रखना चाहिए। विधि के workhorse में निकाला जाना चाहिए executeविधि है, जो उपवर्गों डिफ़ॉल्ट व्यवहार को ओवरराइड करने के लिए अनुमति देता है (एक मुश्किल काम एक एम्बेडेड का उपयोग कर switchऔर goto)।

पायथन उदाहरण

StackOverflow पर पोस्ट किए गए निम्न उत्तर (एक पायथन प्रश्न के विपरीत):

1. हमेशा के लिए पाश।
2. उपयोगकर्ता को अपनी पसंद का इनपुट देने के लिए कहें।
3. यदि उपयोगकर्ता का इनपुट 'रीस्टार्ट' है, तो हमेशा के लिए लूपिंग जारी रखें।
4. अन्यथा, लूप को हमेशा के लिए बंद कर दें।
5. समाप्त।

कोड

while True: 
    choice = raw_input('What do you want? ')

    if choice == 'restart':
        continue
    else:
        break

print 'Break!' 

बनाम:

1. उपयोगकर्ता की पसंद को प्रारंभ करें।
2. लूप जबकि उपयोगकर्ता की पसंद 'पुनरारंभ' शब्द है।
3. उपयोगकर्ता को अपनी पसंद का इनपुट देने के लिए कहें।
4. समाप्त।

कोड

choice = 'restart';

while choice == 'restart': 
    choice = raw_input('What do you want? ')

print 'Break!'

यहां, while Trueभ्रामक और अत्यधिक जटिल कोड के परिणामस्वरूप।

Comments

जो विचार while(true)हानिकारक होना चाहिए वह मुझे विचित्र लगता है। इससे पहले कि वे निष्पादित करें, वहां लूप्स चेक करें, बाद में चेक करने वाले लोग हैं, और बीच में चेक करने वाले भी हैं। चूंकि बाद में C और C ++ में सिंटैक्टिक निर्माण नहीं है, इसलिए आपको इसका उपयोग करना होगा while(true)या for(;;)। यदि आप इसे गलत मानते हैं, तो आपने अभी तक विभिन्न प्रकार के लूपों के लिए पर्याप्त विचार नहीं दिया है।

— sbi

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

— डेविड थॉर्नले

जब भी आप "जबकि (सच्चा)" देखते हैं, तो आप एक लूप के बारे में सोच सकते हैं जिसमें आंतरिक समाप्ति की स्थिति होती है, जो मनमाने अंत की स्थितियों से अधिक कठिन नहीं होती हैं। बस, एक "जबकि (फू)" लूप, जहां फू एक अनियंत्रित तरीके से एक बूलियन चर सेट है, ब्रेक के साथ "जबकि (सच)" से बेहतर नहीं है। आपको दोनों मामलों में कोड को देखना होगा। एक मूर्खतापूर्ण कारण सामने रखना (और सूक्ष्मता एक मूर्खतापूर्ण तर्क है) आपके मामले में मदद नहीं करता है, वैसे।

— डेविड थॉर्नले

@ क्या: मैंने एक कारण दिया: यह लूप प्राप्त करने का एकमात्र तरीका है जो बीच में स्थिति की जांच करता है। क्लासिक उदाहरण: while(true) {string line; std::getline(is,line); if(!is) break; lines.push_back(line);}बेशक मैं इसे एक पूर्वनिर्मित लूप ( std::getlineलूप स्थिति के रूप में उपयोग करके ) में बदल सकता था, लेकिन इसके अपने आप में नुकसान हैं ( lineलूप के दायरे से बाहर एक चर होना होगा)। और अगर मैंने किया, तो मुझे पूछना होगा: हमारे पास वैसे भी तीन छोरें क्यों हैं? हम हमेशा एक पूर्वनिर्मित लूप में सब कुछ बदल सकते हैं। जो सबसे अच्छा लगता है उसका उपयोग करें। यदि while(true)फिट बैठता है, तो इसका उपयोग करें।

— sbi

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

— एलेक्स लेइबोविट्ज

Answer 2

आप उपयोग कर सकते हैं goto।

while ( ... ) {
   switch( ... ) {
     case ...:
         goto exit_loop;

   }
}
exit_loop: ;

Comments

बस उस कीवर्ड के साथ जंगली मत जाओ।

— फ्राग्सवर्थ

यह हास्यास्पद है क्योंकि मैं नीचे उतर जाता हूं क्योंकि लोग पसंद नहीं करते हैं goto। ओपी ने स्पष्ट रूप से झंडे का उपयोग किए बिना उल्लेख किया । क्या आप ओपी की सीमा को देखते हुए बेहतर तरीके से सुझाव दे सकते हैं? :)

— मेहरदाद अफशरी

अपवित्र बस नासमझ गोटो नफरत की भरपाई करने के लिए टी। मुझे लगता है कि मेहरदाद जानता था कि वह यहाँ समझदार समाधान सुझाने के लिए एक-दो अंक गंवाने वाला है।

— माइकल क्रेलिन -

+1, कोई बेहतर तरीका नहीं है, जब ओपी सीमाओं पर विचार किया जाता है। झंडे बदसूरत हैं, पूरे लूप में तर्क को तोड़ते हैं और इस प्रकार समझाना अधिक कठिन होता है।

— जोहान्स शहाब -

दिन के अंत में, गोटो निर्माण के बिना, सभी भाषाएं विफल हो जाती हैं। उच्च स्तरीय भाषाएं इसे बाधित करती हैं, लेकिन यदि आप हुड के नीचे पर्याप्त कठोर दिखते हैं, तो आपको हर लूप मिलेगा, या सशर्त और बिना शर्त शाखाओं को उबालता है। हम कीवर्ड्स, जब तक, स्विच, यदि कीवर्ड्स के लिए उपयोग करते हैं, तो अपने आप को मूर्ख बनाते हैं, लेकिन अंततः वे सभी एक या दूसरे तरीके से GOTO (या JMP) का उपयोग करते हैं। आप अपने आप को बेहोश कर सकते हैं, इसे छिपाने के लिए सभी प्रकार के चतुर तरीके का आविष्कार कर सकते हैं, या आप बस व्यावहारिक रूप से ईमानदार हो सकते हैं, और गोटो का उपयोग कर सकते हैं, जहां उचित और विरल रूप से।

— unsynchronized

Answer 3

एक वैकल्पिक समाधान के continueसाथ संयोजन में कीवर्ड का उपयोग करना है break, अर्थात:

for (;;) {
    switch(msg->state) {
    case MSGTYPE
        // code
        continue; // continue with loop
    case DONE:
        break;
    }
    break;
}

continueप्रत्येक केस लेबल को समाप्त करने के लिए कथन का उपयोग करें, जहाँ आप चाहते हैं कि लूप जारी रहे और breakस्टेटमेंट लेबल को समाप्त करने के लिए कथन का उपयोग करें जिसे लूप समाप्त करना चाहिए।

बेशक यह समाधान केवल तभी काम करता है जब स्विच स्टेटमेंट के बाद निष्पादित करने के लिए कोई अतिरिक्त कोड न हो।

Comments

हालांकि यह वास्तव में बहुत ही सुंदर है, इसका नुकसान यह है कि अधिकांश डेवलपर्स को यह समझने के लिए कि इसे कैसे / क्या काम करना है, पहले इसे एक मिनट के लिए देखना होगा। :(

— sbi

अंतिम वाक्य यह है जो इसे इतना महान नहीं बनाता है :(अन्यथा बहुत साफ कार्यान्वयन है।

— नवफाल

जब आप इसके बारे में सोचते हैं, तो कोई भी कंप्यूटर कोड अच्छा नहीं होता है। हम केवल इसे समझने के लिए प्रशिक्षित हैं। उदाहरण के लिए xml तब तक कचरे की तरह दिखता था जब तक कि मैंने इसे सीखा नहीं। अब इसमें कचरा कम दिख रहा है। for (int x = 0; x <10; ++ x, MoveCursor (x, y)) वास्तव में मेरे प्रोग्राम में लॉजिक एरर का कारण बना। मैं भूल गया कि अद्यतन स्थिति अंत में हुई।

Answer 4

ऐसा करने का एक साफ तरीका यह होगा कि इसे एक समारोह में रखा जाए:

int yourfunc() {

    while(true) {

        switch(msg->state) {
        case MSGTYPE: // ... 
            break;
        // ... more stuff ...
        case DONE:
            return; 
        }

    }
}

वैकल्पिक रूप से (लेकिन 'बुरे व्यवहार'): जैसा कि पहले ही सुझाव दिया गया है कि आप एक गोटो का उपयोग कर सकते हैं, या स्विच के अंदर एक अपवाद फेंक सकते हैं।

Comments

अपवाद का उपयोग किया जाना चाहिए, ठीक है, एक अपवाद को फेंक दें, एक फ़ंक्शन के एक अच्छी तरह से ज्ञात व्यवहार नहीं।

— क्लेमेंट हेरमैन

मैं आफ्टरलाइफ से सहमत हूं: इसे एक फंक्शन में रखें।

— dalle

इस मामले में एक अपवाद को फेंकना वास्तव में बुराई है। इसका अर्थ है "मैं एक गोटो का उपयोग करना चाहता हूं, लेकिन मैंने कहीं पढ़ा है कि मुझे उनका उपयोग नहीं करना चाहिए, इसलिए मैं एक उप-केंद्र के साथ जाऊंगा और स्मार्ट दिखने का नाटक करूंगा"।

— गॉर्पिक

मैं सहमत हूं कि एक अपवाद को फेंकना या एक गोटो का उपयोग करना एक भयानक विचार है, लेकिन वे काम करने के विकल्प हैं और मेरे उत्तर में इस तरह सूचीबद्ध किए गए हैं।

— अल्टरलाइफ़

एक अपवाद को फेंकना GOTO के लिए एक COMEFROM को प्रतिस्थापित कर रहा है। यह मत करो। गोटो बेहतर काम करता है।

— डेविड थॉर्नले

Answer 5

AFAIK C ++ में कोई "डबल ब्रेक" या समान निर्माण नहीं है। निकटतम एक ऐसा होगा goto- जो, जबकि इसके नाम का एक बुरा अर्थ है, भाषा में एक कारण के लिए मौजूद है - जब तक यह सावधानीपूर्वक और संयम से उपयोग किया जाता है, यह एक व्यवहार्य विकल्प है।

Answer 6

आप अपना स्विच इस तरह एक अलग फ़ंक्शन में रख सकते हैं:

bool myswitchfunction()
{
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        return false; // **HERE, I want to break out of the loop itself**
    }
    return true;
}

while(myswitchfunction())
    ;

Answer 7

यहां तक ​​कि अगर आपको गोटो पसंद नहीं है, तो एक लूप से बाहर निकलने के लिए एक अपवाद का उपयोग न करें। निम्नलिखित नमूना दिखाता है कि यह कितना बदसूरत हो सकता है:

try {
  while ( ... ) {
    switch( ... ) {
      case ...:
        throw 777; // I'm afraid of goto
     }
  }
}
catch ( int )
{
}

मैं इस उत्तर gotoमें उपयोग करूंगा । इस मामले में कोड को और अधिक स्पष्ट कर देगा फिर कोई अन्य विकल्प। मुझे उम्मीद है कि यह सवाल मददगार होगा।goto

लेकिन मुझे लगता है कि gotoस्ट्रिंग की वजह से यहाँ इकलौता विकल्प है while(true)। आपको अपने लूप को फिर से बनाने पर विचार करना चाहिए। मुझे लगता है कि निम्नलिखित समाधान होगा:

bool end_loop = false;
while ( !end_loop ) {
    switch( msg->state ) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        end_loop = true; break;
    }
}

या निम्नलिखित भी:

while ( msg->state != DONE ) {
    switch( msg->state ) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
}

Comments

हाँ, लेकिन मुझे अपवाद भी कम

— लगते हैं

एक गोटो का अनुकरण करने के लिए एक अपवाद का उपयोग करना वास्तव में गोटो का उपयोग करने से भी बदतर है! यह संभवतः काफी धीमा भी होगा।

— जॉन कार्टर

@Downvoter: ऐसा इसलिए है क्योंकि मैं बताता हूं, कि आपको अपवाद का उपयोग नहीं करना चाहिए, या इसलिए कि मैं सुझाव दे रहा हूं?

— किरिल वी। ल्याडविंस्की

डाउन-वोटर नहीं - लेकिन ... आपका उत्तर स्पष्ट नहीं है कि आप लूप से बाहर निकलने के अपवाद का उपयोग करने के विचार का प्रस्ताव या निंदा कर रहे हैं। शायद पहला वाक्य होना चाहिए: "भले ही आपको पसंद न हो goto, एक पाश से बाहर निकलने के लिए एक अपवाद का उपयोग न करें:"?

— जोनाथन लेफ़लर

@ जोनाथन लेफ़लर, धन्यवाद, आपने मूल्यवान टिप्पणी का नमूना दिखाया। आपकी टिप्पणियों को ध्यान में रखते हुए उत्तर को अपडेट किया।

— किरिल वी। लयाडविंस्की

Answer 8

इस मामले में लूप से बाहर निकलने के लिए कोई सी ++ निर्माण नहीं है।

या तो लूप को बाधित करने के लिए एक ध्वज का उपयोग करें या (यदि उपयुक्त हो) अपने कोड को एक फ़ंक्शन में निकालें और उपयोग करें return।

Answer 9

आप संभावित रूप से गोटो का उपयोग कर सकते हैं, लेकिन मैं एक ध्वज सेट करना पसंद करूंगा जो लूप को रोकता है। फिर स्विच से बाहर तोड़।

Answer 10

क्यों न केवल अपने लूप में स्थिति को ठीक करें, जिससे समस्या गायब हो जाए?

while(msg->state != DONE)
{
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        // We can't get here, but for completeness we list it.
        break; // **HERE, I want to break out of the loop itself**
    }
}

Answer 11

नहीं, C ++ के पास इसके लिए कोई निर्माण नहीं है, यह देखते हुए कि स्विच ब्लॉक से बाहर निकलने के लिए कीवर्ड "ब्रेक" पहले से ही आरक्षित है। वैकल्पिक रूप से एक निकास ध्वज के साथ एक .. () हो सकता है।

do { 
    switch(option){
        case 1: ..; break;
        ...
        case n: .. ;break;
        default: flag = false; break;
    }
} while(flag);

Answer 12

मुझे लगता है;

while(msg->state != mExit) 
{
    switch(msg->state) 
    {
      case MSGTYPE: // ...
         break;
      case DONE:
      //  .. 
      //  ..
      msg->state =mExit;
      break;
    }
}
if (msg->state ==mExit)
     msg->state =DONE;

Answer 13

यह करने का सबसे सरल तरीका है कि यदि आप SWITCH करते हैं तो इससे पहले कि आप लूप से बाहर निकलने के लिए अपनी स्थिति का परीक्षण कर सकें, एक साधारण आईएफ डाल दें .......... जितना आसान हो सकता है

Comments

उम ... आप उस तर्क को तर्क में रखते हुए और भी सरल हो सकते हैं। मेरा मतलब है कि यह वहाँ क्या है! :)

— मार्क ए। डोनोहे

Answer 14

breakC ++ का कीवर्ड केवल सबसे नेस्टेड एनक्लोजिंग पुनरावृत्ति या switchकथन को समाप्त करता है । इस प्रकार, आप while (true)सीधे switchबयान के भीतर लूप से बाहर नहीं निकल सकते ; हालाँकि आप निम्नलिखित कोड का उपयोग कर सकते हैं, जो मुझे लगता है कि इस प्रकार की समस्या के लिए एक उत्कृष्ट पैटर्न है:

for (; msg->state != DONE; msg = next_message()) {
    switch (msg->state) {
    case MSGTYPE:
        //...
        break;

    //...
    }
}

यदि आपको msg->stateबराबरी के समय कुछ करने की जरूरत है DONE(जैसे कि सफाई की दिनचर्या चलाना), तो उस कोड को forलूप के तुरंत बाद रखें ; अर्थात यदि आपके पास वर्तमान में है:

while (true) {
    switch (msg->state) {
    case MSGTYPE:
        //... 
        break;

    //...

    case DONE:
        do_cleanup();
        break;
    }

    if (msg->state == DONE)
        break;

    msg = next_message();
}

इसके बजाय उपयोग करें:

for (; msg->state != DONE; msg = next_message()) {
    switch (msg->state) {
    case MSGTYPE:
        //...
        break;

    //...
    }
}

assert(msg->state == DONE);
do_cleanup();

Answer 15

यह मुझे बहुत सरल है कि यह स्पष्टीकरण की गहराई पर विचार कर रहा है ... यहाँ आपको बस जरूरत है ...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

जबरदस्त हंसी!! वास्तव में! बस इतना ही चाहिए! एक अतिरिक्त चर!

Answer 16

while(MyCondition) {
switch(msg->state) {
case MSGTYPE: // ... 
    break;
// ... more stuff ...
case DONE:
   MyCondition=false; // just add this code and you will be out of loop.
    break; // **HERE, you want to break out of the loop itself**
}
}

Answer 17

मुझे एक ही समस्या मिली और एक ध्वज का उपयोग करके हल किया गया।

bool flag = false;
while(true) {
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        flag = true; // **HERE, I want to break out of the loop itself**
    }
    if(flag) break;
}

Answer 18

अगर मुझे C ++ सिंटैक्स अच्छी तरह से याद है, तो आप इस तरह से breakस्टेटमेंट में एक लेबल जोड़ सकते हैं goto। तो आप जो चाहते हैं वह आसानी से लिखा जाएगा:

while(true) {
    switch(msg->state) {
    case MSGTYPE: // ...
        break;
    // ... more stuff ...
    case DONE:
        break outofloop; // **HERE, I want to break out of the loop itself**
    }
}

outofloop:
// rest of your code here

Comments

दुर्भाग्य से, आपकी स्मृति दोषपूर्ण है। यह एक अच्छा फीचर होगा, उन दुर्लभ अवसरों पर जहां यह उपयोगी होगा। (मैंने तोड़ने के लिए स्तरों की संख्या के लिए प्रस्ताव देखे हैं, लेकिन वे मुझे देखने के लिए बग की तरह दिखते हैं।)

— डेविड थॉर्नले

तब जावा रहा होगा। जवाब के लिए धन्यवाद। और, ज़ाहिर है, आप बाकी लोगों के साथ भी सही हैं।

— आंद्रेई वजना II

Answer 19

  while(true)
  {
    switch(x)
    {
     case 1:
     {
      break;
     }
    break;
   case 2:
    //some code here
   break;
  default:
  //some code here
  }
}

Comments

उस कोड नमूने के सभी ब्रेक स्विच स्टेटमेंट से बाहर हो जाते हैं।

— डैन हुल्मे