सादे सी में अपवादों को लागू करना

इस लेख की निरंतरता habrahabr.ru/post/131212 है , जहां मैं यह दिखाने जा रहा हूं कि "त्रुटियों को संभालने के लिए सुविधाजनक और एक ही समय में अपवादों का उपयोग न करें", लेकिन वे मेरे हाथों तक नहीं पहुंचे।

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

सबसे पहले, एक सबसिस्टम के आरंभीकरण पर विचार करें, जिसकी आवश्यकता है (उदाहरण के लिए) तीन semaphores, सरणियों और कई फिल्टर (इन सरणियों का उपयोग करके) जो वहां कुछ आगे करेंगे। तो:

//   boolean subsystem_init(subsystem* self) { //  boolean ok = true; ok = ok && sema_create(&self->sema1, 0); ok = ok && sema_create(&self->sema2, 0); ok = ok && sema_create(&self->sema3, 1); //  ok = ok && ((self->buffer1 = malloc(self->buff_size1)) != NULL); ok = ok && ((self->buffer2 = malloc(self->buff_size2)) != NULL); //  ok = ok && filter1_init(&self->f1, &self->x, &self->y, self->buffer1); ok = ok && filter2_init(&self->f2, &self->level, self->buffer2); return ok; } 

यह कोड किसके लिए अच्छा है? सबसे महत्वपूर्ण बात, इसकी गुणवत्ता इसका तर्क रैखिक है। इसमें एक (स्पष्ट) नहीं है यदि , प्रोग्रामर केवल इनिशियलाइज़ेशन अनुक्रम लिखता है। उसी महत्व का एक और गुण यह है कि सभी त्रुटियां आपस में जुड़ी हुई हैं। इस उदाहरण में उपयोग किया गया प्रत्येक फ़ंक्शन विफल हो सकता है - हालाँकि, इस बारे में जानकारी खो नहीं है, लेकिन ऊपरी स्तर पर स्थानांतरित हो जाएगी। हम यह भी नोट करते हैं कि यदि कोई अपवाद होता है (उदाहरण के लिए, buffer2 सरणी के लिए मेमोरी आवंटित करना संभव नहीं था), तो सिस्टम रिक्ति में नहीं जाएगा (यानी उस पर बफर के लिए एक अमान्य पॉइंटर फिसलने से filter2 बनाने का कोई प्रयास नहीं होगा)। सामान्य तौर पर, निम्नलिखित में से कोई भी कार्य नहीं किया जाएगा, और subsystem_init पूरा होने पर एक त्रुटि लौटाएगा। इसके अलावा, इस सबसिस्टम के आरंभीकरण को आसानी से एक शीर्ष-स्तरीय प्रणाली के आरंभीकरण में एकीकृत किया जा सकता है - जो कि इस दृष्टिकोण के लिए भी आवश्यक है।

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

लेकिन हम यहां नहीं रुकेंगे, हम आगे बढ़ेंगे।

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

समस्या नहीं है। हमें प्रत्येक फ़ंक्शन के लिए एक अतिरिक्त पैरामीटर की आवश्यकता है, निम्न प्रकार से:

 typedef struct err_info { int count; int32_t stack[MAX_STACK]; //   ,  }; 

त्रुटि की स्थिति में, सभी कार्यों को निम्नलिखित करना चाहिए:

• स्टैक में एक अद्वितीय आईडी जोड़ें (यदि अभी भी जगह है),
• false लौट कर समारोह से बाहर निकलें।

अधिवेशन के द्वारा, सभी कार्य इस संरचना को अंतिम पैरामीटर के रूप में लेते हैं और इसे समान (उदाहरण के लिए, ई ) कहा जाएगा। चूंकि तर्क अपने आप में एक ही है, इसे एक बार मैक्रो के रूप में लागू किया जाता है, सभी तब इसका उपयोग करते हैं। मूल उदाहरण अब इस तरह दिखेगा:

 //   boolean subsystem_init(subsystem* self, err_info* e) { //  REQ(sema_create(&self->sema1, 0), 0x157DF5F3); REQ(sema_create(&self->sema2, 0), 0x601414A4); REQ(sema_create(&self->sema3, 1), 0x7D8E585D); //  REQ(self->buffer1 = malloc(self->buff_size1), 0x5DEB6FC7); REQ(self->buffer2 = malloc(self->buff_size2), 0x7939EDC5); //  REQ(filter1_init(&self->f1, &self->x, &self->y, self->buffer1, e), 0x4D83E154); REQ(filter2_init(&self->f2, &self->level, self->buffer2, e), 0x5B4D8F8D); return true; } 

(आईडी हाथ से नहीं, निश्चित रूप से, लेकिन उपयुक्त कुंजी दबाकर पसंदीदा आईडीई द्वारा बनाई गई है)

और REQ मैक्रो को स्वयं ही परिभाषित किया जा सकता है, उदाहरण के लिए, इस तरह से:

 #define REQ(X, ID) \ if (X) \ ; \ else { \ if (e->count < MAX_STACK) \ e->stack[e->count++] = ID; \ return false; \ } 

कुल मिलाकर, उच्चतम स्तर पर, हमारे पास आरंभीकरण परिणाम (सफलता / असफलता) और कॉल की एक श्रृंखला होगी, जहां त्रुटि हुई थी, तो बहुत जगह तक।

संक्षेप में:

• ANSI C (किसी भी गैर-मानक एक्सटेंशन का उपयोग न करें) के भीतर बने रहे,
• मिला (लगभग मुफ्त) कॉल स्टैक,
• असाधारण स्थितियों को पकड़ा जाता है,
• कोड रैखिक है, यह रिटर्न मानों की निरंतर जांच से अटे नहीं है, जो गलतियों को करना आसान है,
• यदि हमारे पास "C ++ अपवाद के बिना" है, तो हमें अपवादों की सामान्य पीढ़ी के साथ, पहले से ही बनाए गए स्थानीय चर के विध्वंसक को कॉल मिलते हैं।

ps: हाँ, वास्तव में - यह शायद मठ के कार्यान्वयन है।