C ++ में सेगमेंटेशन फ़ॉल्ट हैंडलिंग

पृष्ठभूमि

C ++ एक "अप्रबंधित" भाषा है, इसलिए प्रोग्राम उपयोगकर्ता डेटा, त्रुटि संदेशों आदि को सहेजे बिना क्रैश कर सकते हैं। - यह केवल आवश्यक है, उदाहरण के लिए, एक असमान स्मृति में चढ़ने के लिए। उदाहरण के लिए:

void fall() { char * s = "short_text"; sprintf(s,"This is very long text"); } 

या

 void fall() { int * pointer = NULL; *pointer = 13; } 

सभी के लिए बेहतर होगा यदि हम एक प्रोग्राम क्रैश को "पकड़" सकते हैं - जैसे कि जावा में अपवादों को पकड़ना - और प्रोग्राम क्रैश होने से पहले कम से कम कुछ करें (उपयोगकर्ता दस्तावेज़ को सहेजें, एक त्रुटि संदेश के साथ एक संवाद प्रदर्शित करें, आदि) आदि)

समस्या का एक सामान्य समाधान नहीं है, क्योंकि C ++ में मेमोरी के साथ काम करने से संबंधित अपवादों को संभालने के लिए अपना मॉडल नहीं है। हालांकि, हम दो तरीकों को देखेंगे जो ऑपरेटिंग सिस्टम की सुविधाओं का उपयोग करते हैं जो अपवाद का कारण बनते हैं।

विधि 1: SEH

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

अपवादों को संभालने के लिए सामान्य वाक्यविन्यास निम्नानुसार है:

 __try { segfault1(); } __except( condition1 ) { //  ,  condition1 == EXCEPTION_EXECUTE_HANDLER. //  condition1  ()   ,  //  ,   EXCEPTION_EXECUTE_HANDLER //     ,     } __except( condition2 ) { //    } __finally { // ,          } 

यहाँ एक "काम करने का उदाहरण" है - "कॉपी और विजुअल स्टूडियो में पेस्ट"

 #include <stdio.h> #include <windows.h> #include <excpt.h> int memento() //  Segfault { MessageBoxA(NULL,"Memento Mori","Exception catched!",NULL); return 0; } void fall() //  segfault { int* p = 0x00000000; *p = 13; } int main(int argc, char *argv[]) { __try { fall(); } __except (EXCEPTION_EXECUTE_HANDLER) { memento(); } } 

मैं व्यक्तिगत रूप से __finally पैसे कमाने के लिए सक्षम नहीं है (यही कारण है कि मैंने __except को एक सत्यापन कोड के साथ लिखा है जो हमेशा काम करता है), लेकिन यह मेरे हाथों की वक्रता हो सकती है।

यह तकनीक, इसके सभी आकर्षण के साथ, इसके कई नुकसान हैं:

• एक संकलक। एक ओएस। "शुद्ध C ++" नहीं। यदि आप एमएस टूल्स के बिना काम करना चाहते हैं - तो आप इस तकनीक का उपयोग नहीं कर सकते
• एक धागा - एक टेबल । यदि आप __try ... __except से कंस्ट्रक्शन लिखते हैं, तो __try के अंदर एक और थ्रेड शुरू करें और, __try को छोड़े बिना, दूसरा थ्रेड segfault को कॉल करेगा, फिर ... कुछ भी नहीं होगा, प्रोग्राम "सामान्य रूप से" क्रैश हो जाएगा। क्योंकि प्रत्येक थ्रेड के लिए आपको एक अलग SEH हैंडलर लिखना होगा।

इतने सारे विपक्ष थे कि आपको दूसरे समाधान की तलाश करनी होगी।

विधि 2: POSIX सिग्नल

विधि यह सुनिश्चित करने के लिए डिज़ाइन की गई है कि दुर्घटना के समय कार्यक्रम को POSIX संदेश SIGSEGV प्राप्त होता है। यह निश्चित रूप से सभी यूनिक्स प्रणालियों पर सच है , लेकिन यह वास्तव में सच है (हालांकि किसी ने गारंटी नहीं दी है कि विंडोज़ पॉज़िक्स-संगत नहीं है) और खिड़कियों पर भी।

तकनीक सरल है - हमें एक SIGSEGV संदेश हैंडलर लिखने की जरूरत है जिसमें कार्यक्रम "विदाई क्रिया" करता है और अंत में गिरता है:

 void posix_death_signal(int signum) { memento(); //   signal(signum, SIG_DFL); //   exit(3); //  .    ,     . } 

जिसके बाद हमें इस हैंडलर को पंजीकृत करना होगा:

 signal(SIGSEGV, posix_death_signal); 

यहाँ एक तैयार उदाहरण दिया गया है:

 #include <stdio.h> #include <stdio.h> #include <windows.h> #include <stdlib.h> #include <signal.h> int memento() { int a=0; MessageBoxA(NULL,"Memento mori","POSIX Signal",NULL); return 0; } void fall() { int* p = 0x00000000; *p = 13; } void posix_death_signal(int signum) { memento(); signal(signum, SIG_DFL); exit(3); } int main(int argc, char *argv[]) { signal(SIGSEGV, posix_death_signal); fall(); } 

एसईएच के विपरीत, यह हमेशा काम करता है: समाधान "मल्टीथ्रेडेड" है (आप किसी भी थ्रेड में प्रोग्राम को ड्रॉप कर सकते हैं, हैंडलर किसी भी मामले में शुरू होगा) और "क्रॉस-प्लेटफॉर्म" - यह किसी भी कंपाइलर के तहत काम करता है, और किसी भी पॉसिक्स-संगत ओएस के तहत।