सी ++: मुख्य लूप

Question

तोड़ने मैं कुछ कोड तैयारी कर रहा हूँ:

for(int a = 1; a <= 100; a++) //loop a (main loop) 
{ 
    for(int b = 1000; b <= 2000; b++) //loop b 
    { 
     if(b == 1555) 
      break; 
    } 

    for(int c = 2001; c <= 3000; c++) //loop c 
    { 
     . 
     . 
     . 
    } 
} 

मैं ख लूप (पाश चर int b) में एक break; बयान का उपयोग करके मुख्य लूप (पाश चर int a) को तोड़ने के लिए चाहते हैं।

मैं यह कैसे कर सकता हूं?

Answer 1

मैं एक समारोह में अपने कोड पुनर्रचना की सिफारिश का प्रयोग करें। तो फिर तुम सिर्फ return कि समारोह के बजाय break का उपयोग करने का से कर सकते हैं:

void myFunc() 
{ 
    for(int a = 1; a <= 100; a++) //loop a (main loop) 
    { 
     for(int b = 1000; b <= 2000; b++) //loop b 
     { 
      if(b == 1555) // Logic is just an example, 
       return; // since it will always return 
     } 

     . 
     . 
     . 
    } 
} 

इस - या अपने कोड की शायद यह भी एक और अधिक शामिल पुनर्रचना - एक साफ, सुरुचिपूर्ण समाधान करने के लिए खुद को उधार देने चाहिए।

for(int a = 1; a <= 100; a++) //loop a (main loop) 
{ 
    bool cond = false; 

    for(int b = 1000; b <= 2000; b++) //loop b 
    { 
     if(b == 1555){ 
      cond = true; 
      break; 
     } 
    } 

    if (cond) break; 

    . 
    . 
    . 
} 

---

दूसरों goto का उपयोग कर सुझाव दिया है: वैकल्पिक रूप से, अगर आप सिर्फ त्वरित सुधार चाहते हैं आप एक शर्त चर का उपयोग कर सकते हैं। हालांकि यह एक और त्वरित फिक्स है, मैं इसके खिलाफ दृढ़ता से अनुशंसा करता हूं, खासकर यदि आप एक कठोर वातावरण में काम कर रहे हैं जहां कोड की समीक्षा की जाएगी और सड़क के नीचे वर्षों तक उपयोग किया जाएगा।

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

Answer 2

goto का उपयोग करें।

for(int a = 1; a <= 100; a++) //loop a (main loop) 
{ 
    for(int b = 1000; b <= 2000; b++) //loop b 
    { 
     if(b == 1555) 
      goto loopDone; 
    } 

    for(int c = 2001; c <= 3000; c++) //loop c 
    { 
     . 
     . 
     . 
    } 
} 
loopDone: 

Answer 3

for(int a = 1; a <= 100; a++) //loop a (main loop) 
{ 
    for(int b = 1000; b <= 2000; b++) //loop b 
    { 
     if(b == 1555) 
      goto end; 
    } 

    for(int c = 2001; c <= 3000; c++) //loop c 
    { 
     . 
     . 
     . 
    } 
} 
end: 

Answer 4

एक समय में इस तरह के दो छोरों से बाहर सिर करने का एकमात्र तरीका goto या एक throw या एक return, और throw और return उपयुक्त नहीं हो सकता (विशेष रूप से throw है, अगर हालत 'isn असाधारण नहीं)। वैकल्पिक रूप से, आप किसी प्रकार की स्थिति (bool breakout;) सेट कर सकते हैं, और यदि यह सच है तो तोड़ना जारी रखें।

Answer 5

पैटर्न

इस तरह का

for(int a = 1; a <= 100; a++) 
{ 
    int breakMain = 0; 
    for(int b = 1000; b <= 2000; b++) 
    { 
     if(b == 1555) 
     { 
      breakMain = 1; 
      break; 
     } 
    } 

    if(breakMain) 
     break; 

    for(int c = 2001; c <= 3000; c++) 
    { 
     . 
     . 
     . 
    } 
} 

Answer 6

1. का प्रयोग करें एक goto:

   for(int a = 1; a <= 100; a++) //loop a (main loop) 
   { 
       for(int b = 1000; b <= 2000; b++) //loop b 
       { 
        if(b == 1555) 
         goto done; 
       } 
       for(int c = 2001; c <= 3000; c++) //loop c 
       { 
        . 
        . 
        . 
       } 
   } 
   done: 
   

2. सेट प्रत्येक पाश द्वारा परीक्षण एक प्रहरी मूल्य:

   bool sentinel = true ; 
   for(int a = 1; a <= 100 && sentinel ; a++) //loop a (main loop) 
   { 
       for(int b = 1000; b <= 2000 && sentinel; b++) //loop b 
       { 
        if(b == 1555) 
         sentinel = false; 
       } 
       for(int c = 2001; c <= 3000 && sentinel; c++) //loop c 
       { 
        . 
        . 
        . 
       } 
   } 
   

Answer 7

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

public void bigLoop() 
{ 
    for(int a = 1; a <= 100; a++) 
    { 
     for(int b = 1000; b <= 2000; b++) 
     { 
      if(b == 1555) 
       return; 
     } 

     for(int c = 2001; c <= 3000; c++) 
     { 
      . 
      . 
      . 
     } 
    } 
}//bigLoop 

Answer 8

एक सरल रणनीति चयनित बिंदु पर एक अलग समारोह में पाश डाल दिया और एक वापसी करना है:

void func() 
{ 
    for(int a = 1; a <= 100; a++) //loop a (main loop) 
    { 
     for(int b = 1000; b <= 2000; b++) //loop b 
     { 
      if(b == 1555) 
       return; 
     } 

     for(int c = 2001; c <= 3000; c++) //loop c 
     { 
      . 
      . 
      . 
     } 
    } 
} 

परिणाम किसी भी तरह का भी या के साथ एक वापसी मान वाला लौटाया जा सकता है, समारोह के लिए एक संदर्भ पैरामीटर। goto उपयोग करते हैं, throw उपयोग करते हैं, एक ध्वज है, या refactor का उपयोग करें:

Answer 9

या तो चार चीजों में से एक है।

कई using goto से असहमत होंगे, लेकिन sometimes यह एक साफ समाधान है। (ज्यादातर बार, यह नहीं है, लेकिन यह किसी कारण से मौजूद है।) हालांकि, मुझे goto का उपयोग एक रिफैक्टर वारंट करता है।

दूसरा समाधान to throw कुछ विशेष अपवाद है और फिर इसे मुख्य लूप के बाहर पकड़ें। यह अपवाद प्रणाली का दुरुपयोग है और मूल रूप से एक खराब goto; इसके बजाय goto का उपयोग करें।

तीसरा समाधान के a flag का उपयोग करना होगा। यह मूल रूप से एक "सुरक्षित" goto है, लेकिन कुछ तर्क दे सकते हैं कि यह थोड़ा उलझन में है। (इस तरह के एक मामले में विशेष रूप से बहु-स्तर के साथ। हालांकि आपकी चिंता कैसे बदसूरत अपने कोड है।)

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

Answer 10

आदर्श तरीका आपके कोड को फिर से कारक बनाना होगा ताकि आपको अब ऐसी जटिल नेस्टेड-लूप संरचना की आवश्यकता न हो। आपके शेष कोड की तरह दिखने के आधार पर, आपके b और c लूप अलग-अलग फ़ंक्शन बनने के लिए उम्मीदवार हो सकते हैं, अगर पूरे a लूप नहीं हैं।

चूंकि यह लूप b और c आसन्न श्रृंखलाओं पर फिर से दिखता है, क्यों न उन्हें संयोजित करें और थोड़ा सा घोंसला घोंसला कम करें?

for (int a = 1; a <= 100; a++) //loop a (main loop) 
{ 
    int count = 1000; 
    while (count <= 3000) // combined loops 'b' and 'c' 
    { 
     if (count <= 2000) 
     { 
      // Old loop 'b' code 
      if (b == 1555) 
       goto fullbreak; 
     } 
     else 
     { 
      // Old loop 'c' code 
      ... 
     } 
     count++; 
    } 
} 
fullbreak: 

आप goto के बजाय एक शर्त चर का भी उपयोग कर सकते हैं। यदि आप पुराने b पाश से बाहर निकलना चाहते हैं लेकिन अभी भी पुराने c लूप को संसाधित करना चाहते हैं, तो पुराने b लूप कोड के अंदर बस count = 2001 सेट करें।

आदर्श रूप में, आप कम से कम और अधिक की तरह

for (int a = 1; a <= 100; a++) //loop a (main loop) 
{ 
    if (process_inner_loop(pass, required, args)) 
     break; 
} 

कुछ करने के लिए फिर से कारक को यह सक्षम हो जाएगा जहां समारोह process_inner_loop अपने मूल दो छोरों तक लपेटता है और रिटर्न गैर शून्य आप से बाहर तोड़ करना चाहते हैं संलग्न लूप। अब, goto या हालत चर का उपयोग करने के बजाय, आप बस return 1; कर सकते हैं।

Answer 11

\ (◕ ◡ ◕)/

[]() { 
    for(int a = 1; a <= 100; a++) //loop a (main loop) 
    { 
     for(int b = 1000; b <= 2000; b++) //loop b 
     { 
      if(b == 1555) 
       return; 
     } 

     for(int c = 2001; c <= 3000; c++) //loop c 
     { 
      . 
      . 
      . 
     } 
    } 
}();