नया (std :: nothrow) बनाम एक कोशिश/पकड़ ब्लॉक

Question

new सीखने के बाद मैंने कुछ शोध किया, malloc() के विपरीत, जिसका उपयोग मैं किया जाता हूं, असफल आवंटन के लिए NULL वापस नहीं करता है, और पाया कि दो अलग-अलग तरीके हैं यह जांचने के लिए कि क्या नया सफल हुआ या नहीं। उन दो तरीके हैं:

try 
{ 
    ptr = new int[1024]; 
} 
catch(std::bad_alloc& exc) 
{ 
    assert(); 
}; 

और

ptr = new (std::nothrow) int[1024]; 
if(ptr == NULL) 
    assert(); 

मेरा मानना ​​है कि दो तरह से एक ही लक्ष्य को पूरा, (! मुझे ठीक कर लें मैं निश्चित रूप से गलत हूँ), इसलिए मेरे सवाल यह है:

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

Answer 1

विचार करें कि आप क्या कर रहे हैं। आप स्मृति आवंटित कर रहे हैं। और अगर किसी कारण से स्मृति आवंटन काम नहीं कर सकता है, तो आप assert। यदि आप std::bad_alloc को main पर प्रचारित करते हैं तो बस इतना ही कम होगा कि क्या होगा। रिलीज बिल्ड में, जहां assert नो-ऑप है, जब आपका मेमोरी एक्सेस करने का प्रयास करता है तो आपका प्रोग्राम क्रैश हो जाएगा। तो यह अपवाद बबल अप देने जैसा ही है: ऐप को रोकना।

तो अपने आप से एक प्रश्न पूछें: क्या आप वास्तव में पर ध्यान देने की ज़रूरत है कि अगर आप स्मृति से बाहर हो जाते हैं तो क्या होता है? यदि आप जो भी कर रहे हैं, वह जोर दे रहा है, तो अपवाद विधि बेहतर है, क्योंकि यह आपके कोड को यादृच्छिक assert एस के साथ अव्यवस्थित नहीं करता है। आप बस अपवाद को main पर गिरने दें।

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

Answer 2

यह आवंटन कहां हो रहा है इसके संदर्भ पर निर्भर करता है। यदि आपका प्रोग्राम जारी रहता है भले ही आवंटन विफल हो (शायद कॉलर को एक त्रुटि कोड लौटाएं) तो std::nothrow विधि का उपयोग करें और न्यूल की जांच करें। अन्यथा आप नियंत्रण प्रवाह के लिए अपवादों का उपयोग करेंगे, जो कि अच्छा अभ्यास नहीं है।

दूसरी ओर, अपने कार्यक्रम पूरी तरह से से शान से कि स्मृति क्रम में सफलतापूर्वक आवंटित करने के लिए (new के आसपास के क्षेत्र में जरूरी नहीं), में कार्य try-catch का उपयोग को पकड़ने के लिए करने में सक्षम होने की जरूरत है, तो एक अपवाद और बाहर निकलें कार्यक्रम।

Answer 3

शुद्ध प्रदर्शन परिप्रेक्ष्य से यह थोड़ा मायने रखता है। अपवाद हैंडलिंग के साथ अंतर्निहित ओवरहेड है, हालांकि यह ओवरहेड आमतौर पर आवेदन पठनीयता और रखरखाव में व्यापार के लायक है। इस प्रकृति की स्मृति आवंटन विफलताओं को आपके आवेदन के 99% मामले में नहीं होना चाहिए, इसलिए यह अक्सर घटित होना चाहिए।

एक प्रदर्शन परिप्रेक्ष्य से आप आम तौर पर इसके अपेक्षाकृत खराब प्रदर्शन के कारण मानक आवंटन से बचना चाहते हैं।

यह सब कहा, मैं आमतौर पर अपवाद फेंकने संस्करण स्वीकार करता हूं क्योंकि आम तौर पर हमारे अनुप्रयोग ऐसे राज्य में होते हैं जहां स्मृति आवंटन विफल रहता है, तो उचित त्रुटि संदेश के साथ बाहर निकलने के अलावा हम कुछ भी नहीं कर सकते हैं, और हम प्रदर्शन को सहेजते हैं NULL हमारे नए आवंटित संसाधनों की जांच करने की आवश्यकता नहीं है क्योंकि परिभाषा के अनुसार आवंटन विफलता उस मामले से बाहर निकल जाएगी जहां से यह महत्वपूर्ण है।

Answer 4

new वस्तुओं को बनाने के लिए उपयोग किया जाता है, स्मृति आवंटित नहीं किया जाता है, इसलिए आपका उदाहरण कुछ कृत्रिम है।

ऑब्जेक्ट कन्स्ट्रक्टर आम तौर पर विफल होने पर फेंक देते हैं। विजुअल स्टूडियो में new कार्यान्वयन के माध्यम से कुछ बार से अधिक कदम उठाने के बाद, मुझे विश्वास नहीं है कि कोड में कोई अपवाद है। इसलिए वस्तुओं को बनाते समय अपवादों को देखना आम तौर पर समझ में आता है।

I सोचेंstd::bad_alloc केवल तभी फेंक दिया जाता है जब स्मृति आवंटन भाग विफल हो जाता है। मुझे यकीन नहीं है कि क्या होता है यदि आप std::nothrow से new पास करते हैं लेकिन ऑब्जेक्ट कन्स्ट्रक्टर फेंकता है - मैंने जो दस्तावेज़ पढ़े हैं उनमें अस्पष्टता है।

2 दृष्टिकोणों के बीच प्रदर्शन में अंतर शायद अप्रासंगिक है क्योंकि अधिकांश प्रोसेसर समय ऑब्जेक्ट कन्स्ट्रक्टर में आसानी से खर्च किया जा सकता है या ढेर खोज सकता है।

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