सी ++, क्या यह गोटो स्टेटमेंट जरूरी है?

Question

मैंने थोड़ा शीर्षक बदल दिया है क्योंकि मैंने सोचा कि यह अधिक उचित सवाल है।

क्या आप इसे पुन: सक्रिय करेंगे (गोटो के वैध उपयोग की तरह लगता है)? यदि, आप कथन पर जाने के लिए निम्न कोड को कैसे दोबारा प्रतिक्रिया देंगे?

if (data.device) { 
    try { 
     ... 
    } 
    catch(const std::exception&) { goto done; } 
    ... // more things which should not be caught 
done: ; 
} 

पूरा बयान

#ifdef HAVE_GPU 
      // attempt to use GPU device 
      if (data.device) { 
       try { 
        Integral::Gpu eri(S, R, Q, block.shell()); 
        eri(basis.centers(), quartets, data.device); 
       } 
       // if GPU fails, propagate to cpu 
       catch(std::exception) { goto done; } 
       data.device += size; 
       host_index.extend(block_index); 
       block_index.data.clear(); 
      done: ; 
      } 
#endif 

धन्यवाद

के बाद सबसे की वरीयता को देखा है, मैं ध्वज के साथ जाने का फैसला किया है, लेकिन श्री यॉर्क में टिप्पणी के साथ।

धन्यवाद हर कोई

Answer 1

if (data.device) 
{ 
    bool status = true; 

    try 
    { 
     ... 
    } 
    catch(std::exception) 
    { 
     status = false; 
    } 

    if (status) 
    { 
    ... // more things which should not be caught 
    } 
} 

Answer 2

आप बाहर अपवाद नहीं पकड़ सकते तो क्या होगा?

Answer 3

if (data.device) { 
    bool ok = true; 
    try { 
     ... 
    } 
    catch(std::exception) { ok = false; } 

    if(ok) { 
     ... // more things which should not be caught 
    } 
} 

Answer 4

आप अपवाद को पकड़ने और एक विशिष्ट अपवाद है कि सशर्त ब्लॉक के बाहर से संभाला जा सकता rethrow कर सकते हैं।

// obviously you would want to name this appropriately... 
struct specific_exception : std::exception { }; 

try { 
    if (data.device) { 
     try { 
      // ... 
     } 
     catch(const std::exception&) { 
      throw specific_exception(); 
     } 

     // ... more things which should not be caught ... 
    } 
} 
catch (const specific_exception&) { 
    // handle exception 
} 

Answer 5

कुछ ध्वज का उपयोग करने और सशर्त बयान जोड़ने के बारे में क्या?

int caught = 0; 
if (data.device) { 
    try { 
     /* ... */ 
    } catch (std::exception e) { caught = 1; } 
    if (!caught) { 
     // more stuff here 
    } 
    // done: ... 
} 

Answer 6

पहला: गोटो प्रति बुरा नहीं है। आपके कोड में "गोटो" अक्षरों को न रखने के शुद्ध शुद्धता के लिए प्रतिक्रिया करना बकवास है। इसे किसी चीज पर दोबारा दोबारा करने के लिए जो एक गेटो की तुलना में क्लीनर किया जाता है ठीक है। खराब डिजाइन को एक में बदलना जो बेहतर है और इसके लिए गेटो या प्रतिस्थापन की आवश्यकता नहीं है, ठीक है।

कहा जा रहा है कि, मैं कहूंगा कि आपका कोड ठीक उसी तरह दिखता है जिसकी आखिर में आविष्कार किया गया था। बहुत दुखी सी ++ में ऐसा कुछ नहीं है ... तो शायद सबसे आसान समाधान इसे छोड़ना है।

Answer 7

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

Answer 8

catch(std::exception) { return; } 

यह चाल चलाना चाहिए। मैं निश्चित रूप से यह मान रहा हूं कि done वास्तव में एक फ़ंक्शन के अंत में है।

यदि अपवाद होने पर आपको अतिरिक्त कोड निष्पादित करने की आवश्यकता है, तो स्थिति लौटाएं या अपवाद को अधिक उचित स्तर पर अपवाद फेंक दें (जेम्स का जवाब देखें)।

मैं की तरह कुछ कल्पना कर रहा हूँ:

doStuff(...) { 
    bool gpuSuccess = doGPUStuff(...); 
    if (!gpuSuccess) { 
     doCPUStuff(...); 
    } 
} 

Answer 9

क्यों कोशिश ब्लॉक के अंदर अतिरिक्त कोड कदम नहीं ?:

#ifdef HAVE_GPU 
      // attempt to use GPU device 
      if (data.device) { 
       try { 
        Integral::Gpu eri(S, R, Q, block.shell()); 
        eri(basis.centers(), quartets, data.device); 
        data.device += size; 
        host_index.extend(block_index); 
        block_index.data.clear(); 
       } 
       // if GPU fails, propagate to cpu 
       catch(std::exception) { /* handle your exception */; } 
      } 
#endif 

Answer 10

मुझे लगता है कि इस का एक प्रकार आप के लिए काम कर सकते हैं।

// attempt to use GPU device 
if (data.device) 
{ 
    try 
    { 
     Integral::Gpu eri(S, R, Q, block.shell()); 
     eri(basis.centers(), quartets, data.device); 

     data.device += size; 
     host_index.extend(block_index); 
     block_index.data.clear(); 
    } 
    catch (const std::bad_alloc&) 
    { 
     // this failure was not because 
     // of the GPU, let it propagate 
     throw; 
    } 
    catch(...) 
    { 
     // handle any other exceptions by 
     // knowing it was the GPU and we 
     // can fall back onto the CPU. 
    } 
} 

// do CPU 

आप GPU पुस्तकालय को संपादित करने और सभी GPU अपवाद gpu_exception जैसे कुछ आधार दे सकता है, तो कोड बहुत सरल हो जाता है:

// attempt to use GPU device 
if (data.device) 
{ 
    try 
    { 
     Integral::Gpu eri(S, R, Q, block.shell()); 
     eri(basis.centers(), quartets, data.device); 

     data.device += size; 
     host_index.extend(block_index); 
     block_index.data.clear(); 
    } 
    catch (const gpu_exception&) 
    { 
     // handle GPU exceptions by 
     // doing nothing and falling 
     // back onto the CPU. 
    } 

    // all other exceptions, not being 
    // GPU caused, may propagate normally 
} 

// do CPU 

यदि इन काम के निचले, मुझे लगता है कि दूसरी सबसे बड़ी चीज है Steve's answer।

Answer 11

ध्वज का थोड़ा अलग उपयोग। मुझे लगता है कि यह अमरदीप की तुलना में साफ है।

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

#ifdef HAVE_GPU 
    // attempt to use GPU device 
    if (data.device) { 
     bool dont_catch = false; 
     try { 
      ... 
      dont_catch = true; 
      ... // more things which should not be caught 
     } catch (...) { 
      if (dont_catch) throw; 
     } 
    } 
#endif 

Answer 12

Am मैं कुछ याद आ रही है, या यह catch और try ब्लॉक के अंदर done: लेबल के बीच हिस्सा ले जाने के लिए बराबर नहीं हो सकता है?

#ifdef HAVE_GPU 
      // attempt to use GPU device 
      if (data.device) { 
       try { 
        Integral::Gpu eri(S, R, Q, block.shell()); 
        eri(basis.centers(), quartets, data.device); 
        data.device += size; 
        host_index.extend(block_index); 
        block_index.data.clear(); 
       } 
       // if GPU fails, propagate to cpu 
       catch(std::exception) {} 
      } 
#endif 

Answer 13

बस इसे बाहर तोड़ अपनी ही समारोह/विधि (इसके बाद सब कुछ शामिल है) में और return कीवर्ड का उपयोग करें। जब तक आपके सभी चर के पास विनाशक होते हैं, तब तक स्टैक-आवंटित होते हैं (या अपरिहार्य होने पर स्मार्ट-पॉइंटर किए जाते हैं), तो आप ठीक हैं। मैं निरंतर ध्वज-जांच के बजाए प्रारंभिक निकास कार्यों/विधियों का एक बड़ा प्रशंसक हूं।

उदाहरण के लिए

:

void myFunc() 
{ 
    String mystr("heya"); 
    try 
    { 
     couldThrow(mystr); 
    } 
    catch(MyException& ex) 
    { 
     return; // String mystr is freed upon returning 
    } 

    // Only execute here if no exceptions above 
    doStuff(); 
} 

इस तरह, यह गलत जाना मुश्किल है

Answer 14

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

फिर इसे अपने मूल कार्य से कॉल करें।

के बाद से वे शायद कुछ चर (data, host_index और block_index, यह तरह दिखता है) साझा करने के लिए की आवश्यकता होगी, उन्हें एक वर्ग में रखा, और इसके बारे में दो कार्यों के सदस्यों बनाते हैं।

void RunOnGpu(){ 
     // attempt to use GPU device 
     if (data.device) { 
      try { 
       Integral::Gpu eri(S, R, Q, block.shell()); 
       eri(basis.centers(), quartets, data.device); 
      } 
      // if GPU fails, propagate to cpu 
      catch(std::exception) { return; } 
      data.device += size; 
      host_index.extend(block_index); 
      block_index.data.clear();  
} 
void DoStuff() { 
#ifdef HAVE_GPU 
    RunOnGpu(); 
#endif 
}