सी ++ में फ़ंक्शन-व्यापी अपवाद हैंडलिंग - क्या यह एक खराब शैली है?

Question

वहाँ है कार्यों के बारे में एक कोशिश पकड़ बात है, जो मैं कभी कभी लगता है कि काफी उपयोगी हो सकता है:

bool function() 
try 
{ 
    //do something 
} 
catch(exception_type & t) 
{ 
    //do something 
} 

तो सवाल के पहले भाग: इस शैली बुरा सामान्य स्थिति में माना जाता है?

और ठोस उदाहरण मैं में इस दृष्टिकोण का इस्तेमाल किया:

हम सी और सी में कोड की काफी एक बहुत ++ के साथ इस परियोजना के लिए किया था। और वहां हमारे पास कस्टम अपवाद प्रकार थे (std :: अपवाद नहीं लिया गया)। मुझे एक्सएमएल लाइब्रेरी को एकीकृत करने और हमारे प्रकार के सभी अपवादों को डालने की आवश्यकता थी। तो, मूल रूप से, अंतिम चरण एक्सएमएल लाइब्रेरी से सभी अपवादों को पकड़ना और उन्हें परिवर्तित करना था।

समारोह से पहले:

bool readEntity(...) 
{ 
    while(...) 
    { 
     if(...) 
     { 
     //lot's of code... 
     } 
    } 
} 

के बाद:

bool readEntity(...) 
try 
{ 
    while(...) 
    { 
     if(...) 
     { 
     //lot's of code... 
     } 
    } 
} 
catch(XMLBaseException & ex) 
{ 
    //create our exception and throw 
} 

मेरे विचार कुछ इस तरह चला गया: मैं स्पष्ट रूप से मेरे इरादों राज्य सब अपवाद कस्टम प्रकार में एक प्रकार से प्राप्त कन्वर्ट करने के लिए और हम रखने के हमारे बिना क्षैतिज स्क्रॉल बार के स्क्रीन (क्षैतिज स्क्रॉल बार खराब हैं)।

ठीक है, मुझे कोड समीक्षा के दौरान गैर-स्पष्ट एक के रूप में वास्तव में इस दृष्टिकोण के लिए काफी आलोचना की गई थी।

तो मैं आपको विचार सुनना चाहता हूं।

अद्यतन: बस स्पष्ट होना: फ़ंक्शन को रीफैक्टर करना एक विकल्प नहीं था। और वास्तव में यह एक अच्छा लिखा गया था।

Answer 1

वास्तव में फ़ंक्शन-स्तरीय प्रयास ब्लॉक का एकमात्र कारण रचनाकारों के लिए है, अन्यथा यह कुछ हद तक अस्पष्ट सुविधा है जो आपको इतना अधिक नहीं खरीदती है।

bool readEntity(...) 
{ 
    try 
    { 
     while(...) 
     { 
     if(...) 
     { 
      //lot's of code... 
     } 
     } 
    } 
    catch(XMLBaseException & ex) 
    { 
     //create our exception and throw 
    } 
} 

आप क्षैतिज स्क्रॉल के साथ समस्याएं हो रहे हैं तो ऐसा करने के लिए बात अपने कोड को विभाजित करने के लिए है: यह यह इस तरह से करने के लिए बस के रूप में आसान है। कोशिश/पकड़ जटिलता हैं और इसे घोंसले के स्तर में दर्शाया जाना चाहिए, छुपा नहीं।

कंस्ट्रक्टर्स में, यह एक अलग मुद्दा है: वहाँ एक प्रारंभकर्ता सूची में अपवाद को पकड़ने के लिए कोई दूसरा रास्ता नहीं है:

SomeClass::SomeClass(parameter p1, parameter p2) : Member1(p1), Member2(p2) 
try 
{ 
} 
catch(Exception &ex) 
{ 
    // handle and rethrow 
} 

बेशक

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

इस पर चर्चा के लिए यह GOTW देखें।

Answer 2

बस स्पष्ट होना: अपवादों को पुनर्स्थापित करना और पुन: पैकेज करना खराब अभ्यास नहीं है, यह एक अच्छी बात है क्योंकि यह बाह्य निर्भरताओं के संपर्क को कम करता है।

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

Answer 3

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

Answer 4

कन्स्ट्रक्टर/फ़ंक्शन की सामान्य बेकारता के बारे में अच्छी चर्चा है Herb Sutters GotW site पर ब्लॉक का प्रयास करें।