एक कन्स्ट्रक्टर को संभालने का अपवाद

Question

यह मेरा साक्षात्कार प्रश्न था।

आश्चर्य की बात है कि मैंने कभी इस तरह के सवाल के बारे में सोचा नहीं।

क्या हमारे पास एक निर्माता सी ++ के अंदर अपवाद हैंडलिंग हो सकता है?

तनाव में और बहुत कुछ नहीं सोचते मैंने कहा "हाँ हम शायद इसे एक निर्माता में कर सकते हैं .लेट्स का कहना है कि हम एक नए सूचक का उपयोग करके एक सूचक सदस्य को कुछ स्मृति आवंटित कर रहे हैं और यह एक खराब आवंटन अपवाद फेंकता है, इस तरह से उठाए जा रहे अपवादों की संभावना "

बाद में मैंने सोचा कि निर्माता कभी भी मूल्य वापस नहीं कर सकते हैं। तो एक कन्स्ट्रक्टर के अंदर एक अपवाद कैसे पकड़ा जा सकता है। अब मैं खुद से यह पूछ रहा हूं!

क्या कोई मुझे इस भ्रम से बाहर निकलने में मदद कर सकता है?

Answer 1

यह GOTW Constructor Failures प्रश्न देखें जो आपकी क्वेरी को कुछ हद तक संबोधित करता है और कहता है कि यह समय बर्बाद है।

Answer 2

सी ++ में अन्य भाषाओं के समान प्रयास करने की कोशिश की गई है। एक ट्यूटोरियल ऑनलाइन पाया जा सकता: http://www.cplusplus.com/doc/tutorial/exceptions/

संपादित करें: उदाहरण के लिए पूरी तरह से काम कर रहे कोड में बदल गया

#include <iostream> 
using namespace std; 

class A 
{ 
public: 
    void f(){ 
    throw 10; 
    } 

    A(){ 
    try{ 
     f(); 
    } 
    catch(int e){ 
     cout << "Exception caught\n"; 
    } 
    } 
}; 

int main (int argc, const char * argv[]) 
{ 

    A a; 
    return 0; 
} 

यह पैदा करता है उत्पादन:

Exception caught 

Answer 3

कंस्ट्रक्टर्स एक वापसी प्रकार नहीं है, इसलिए कोड का उपयोग करना संभव नहीं है। सिग्नल विफलता को सिग्नल करने का सबसे अच्छा तरीका अपवाद फेंकना है। यदि आपके पास अपवादों का उपयोग करने का विकल्प नहीं है, तो "कम से कम खराब" कार्य-आसपास ऑब्जेक्ट को द्वारा "ज़ोंबी" स्थिति में एक आंतरिक स्थिति बिट सेट करना है ताकि ऑब्जेक्ट इस प्रकार की तरह कार्य करता है मृत भले ही यह तकनीकी रूप से जीवित है।

आप कन्स्ट्रक्टर के भीतर नहीं, कॉलिंग कोड में अपवाद पकड़ लेंगे।

अधिक जानकारी के लिए How can I handle a constructor that fails? देखें (वास्तव में, मैं अपवाद हैंडलिंग के बारे में पूरे पृष्ठ को पढ़ने का सुझाव देता हूं, वास्तव में प्रबुद्ध)।

Answer 4

अपवाद हैंडलिंग और वापसी प्रकार पूरी तरह से अलग हैं। जब प्रोग्राम को कन्स्ट्रक्टर में अपवाद मिलता है, तो यह कैच ब्लॉक [अगर उपयोग किया जाता है] या कॉलर (मुख्य()) पर फेंक दिया जाता है। इस मामले में, हमारे पास कन्स्ट्रक्टर में पकड़ ब्लॉक है और इसके द्वारा संभाला गया अपवाद है। एक बार अपवाद संभालने के बाद, कन्स्ट्रक्टर/फ़ंक्शन में शेष बयान निष्पादित करना शुरू कर दिया जाएगा। नीचे उदाहरण देखें,

class A 
{ 
    public: 
    A(){ 
     printf("Hi Constructor of A\n");   
    try 
    { 
     throw 10; 
    } 
    catch(...) 
    { 
     printf("the String is unexpected one in constructor\n"); 
    } 
    printf("Hi Constructor of A\n"); 
} 
    ~A(){ 
    printf("Hi destructor of A\n"); 
} 
}; 

int main() 
{ 

try{ 
    A obj ; 
    throw "Bad allocation"; 
} 
catch(int i) 
{ 
    printf("the Exception if Integer is = %d\n", i); 
} 
catch(double i) 
{ 
    printf("the Exception if double is = %f\n", i); 
} 
catch(A *objE) 
{ 
    printf("the Exception if Object \n"); 
} 
catch(...) 
{ 
    printf("the Exception if character/string \n"); 
} 
printf("Code ends\n"); 
return 0; 
} 

इस उत्पादन का उत्पादन:

Start: Constructor of A 
the String is unexpected one in constructor 
End: Constructor of A 
Hi destructor of A 
the Exception if character/string 
Code ends