उदाहरण 1: C++ में एक कस्टम अपवाद क्लास बनाने का प्रोग्राम
यह सरल उदाहरण C++ में कस्टम अपवाद हैंडलिंग और डिटेक्शन को प्रदर्शित करने के लिए कार्यान्वित किया गया है।
#शामिल करें#शामिल <अपवाद>
का उपयोग करते हुए नाम स्थान कक्षा ;
कक्षा डेमो अपवाद : जनता अपवाद
{
आभासी कॉन्स्ट चार * क्या ( ) कॉन्स्ट फेंक ( )
{
वापस करना 'पकड़ा गया कस्टम अपवाद' ;
}
} ;
int यहाँ मुख्य ( )
{
डेमोएक्सेप्शन dEx ;
कोशिश
{
फेंक डेक्स ;
}
पकड़ना ( अपवाद & के अलावा )
{
अदालत << के अलावा। क्या ( ) << अंतः ;
}
वापस करना 0 ;
}
हम 'iostream' और 'अपवाद' सहित कोड में हेडर फ़ाइल को परिभाषित करते हैं। 'आईओस्ट्रीम' को विशेष रूप से इनपुट और आउटपुट स्ट्रीम के लिए बुलाया जाता है, जबकि 'अपवाद' लाइब्रेरी को अपवाद को संभालने के लिए बुलाया जाता है। इसके बाद, हम 'डेमोएक्सेप्शन' क्लास बनाते हैं जो C++ के 'एक्सेप्शन' क्लास से लिया गया है। यहां, हम वर्चुअल व्हाट() फ़ंक्शन सेट करते हैं जिसका उपयोग const char* प्रदान करने के लिए किया जाता है जो अपवाद से जुड़े त्रुटि संदेश के परिणाम प्रदर्शित करता है।
फिर, हम एक मुख्य() फ़ंक्शन को लागू करते हैं जहां हम 'डेमोएक्सेप्शन' वर्ग का 'dEx' ऑब्जेक्ट बनाते हैं। उसके बाद, हमारे पास एक 'कोशिश' ब्लॉक परिभाषा है जो सामने आने पर अपवाद को फेंक देती है। यहां, हम 'dEx' ऑब्जेक्ट फेंकते हैं।
इसके बाद, हम अपवाद को पकड़ने और उसे संभालने के लिए 'कैच' ब्लॉक सेट करते हैं। हम क्लास अपवाद के संदर्भ को उससे प्राप्त अपवाद को पकड़ने के लिए एक पैरामीटर के रूप में पास करते हैं। 'कैच' ब्लॉक के अंदर, हम कंसोल पर अपवाद संदेश प्राप्त करने के लिए 'एक्सेप्ट' पर व्हाट्स () फ़ंक्शन को कॉल करते हैं।
दिए गए प्रोग्राम को निष्पादित करने के बाद, कस्टम अपवाद संदेश पकड़ा जाता है और कंसोल पर फेंक दिया जाता है:
उदाहरण 2: दो वर्गों का उपयोग करके एक कस्टम अपवाद बनाने का कार्यक्रम
कार्यक्रम कई अपवादों से निपटने पर जोर देता है जिन्हें कई वर्गों को परिभाषित करके स्वतंत्र रूप से नियंत्रित किया जा सकता है।
#शामिल करें
का उपयोग करते हुए नाम स्थान कक्षा ;
कक्षा मूल्यांकन1 { } ;
कक्षा मूल्यांकन2 { } ;
int यहाँ मुख्य ( ) {
कोशिश {
फेंक मूल्यांकन1 ( ) ;
}
पकड़ना ( मूल्यांकन1 ई ) {
अदालत << 'मूल्यांकन1 अपवाद पकड़ा गया!' << अंतः ;
}
कोशिश {
फेंक मूल्यांकन2 ( ) ;
}
पकड़ना ( मूल्यांकन2 ई ) {
अदालत << 'मूल्यांकन 2 अपवाद पकड़ा गया!' << अंतः ;
}
वापस करना 0 ;
}
दिए गए कोड में, हमारे पास दो वर्गों, 'मूल्यांकन1' और 'मूल्यांकन2' की परिभाषा है, जो अब खाली हैं। उसके बाद, हम प्रोग्राम का मुख्य() फ़ंक्शन निष्पादित करते हैं। यहां, हम प्रयास {} ब्लॉक सेट करते हैं जहां 'थ्रो' कीवर्ड का उपयोग 'इवैल्यूएशन1()' क्लास के उदाहरण को फेंकने के लिए किया जाता है। यह दर्शाता है कि यदि इस 'कोशिश' ब्लॉक के अंदर प्रोग्राम में कोई अपवाद उत्पन्न होता है तो 'मूल्यांकन1' अपवाद फेंक दिया जाता है। उसके बाद, हमारे पास एक कैच {} ब्लॉक है जहां अपवाद पकड़ा जाता है और अपवाद का संदेश प्रदर्शित करता है।
इसी तरह, हमारे पास 'मूल्यांकन2' वर्ग के लिए एक और प्रयास {} ब्लॉक की परिभाषा है। उस प्रयास {} ब्लॉक के अंदर, हम 'मूल्यांकन2' वर्ग का उदाहरण डालते हैं। यदि यहां कोई त्रुटि होती है तो यह 'मूल्यांकन2' का अपवाद फेंक देता है। फिर, यदि इस ब्लॉक के भीतर अपवाद पकड़ा जाता है, तो हम 'काउट' कमांड का उपयोग करके अपवाद संदेश प्रदर्शित करने के लिए कैच {} ब्लॉक को कॉल करते हैं।
अलग-अलग 'ट्राई-कैच' ब्लॉक के दो अपवाद कंसोल में फेंके जाते हैं जिन्हें दो अलग-अलग वर्गों द्वारा नियंत्रित किया जाता है।
उदाहरण 3: कंस्ट्रक्टर के साथ एक कस्टम अपवाद बनाने का प्रोग्राम
अपवाद को संभालने के लिए प्रोग्राम कंस्ट्रक्टर का उपयोग करता है। भले ही हम कंस्ट्रक्टर से मान प्राप्त नहीं कर सकते, हम 'ट्राई-कैच' ब्लॉक का उपयोग करके इसे प्राप्त कर सकते हैं।
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
कक्षा परीक्षा {
int यहाँ वैल ;
जनता :
परीक्षा ( int यहाँ एन )
{
कोशिश {
अगर ( एन == 0 )
वैल = एन ;
प्रदर्शन ( ) ;
}
पकड़ना ( कॉन्स्ट चार * ऍक्स्प ) {
अदालत << 'अपवाद मिला \एन ' ;
अदालत << ऍक्स्प << अंतः ;
}
}
खालीपन प्रदर्शन ( )
{
अदालत << 'मूल्य = ' << वैल << अंतः ;
}
} ;
int यहाँ मुख्य ( )
{
परीक्षा ( 0 ) ;
अदालत << 'फिर से उदाहरण बनाना \एन ' ;
परीक्षा ( 1 ) ;
}
दिए गए कोड में, हम 'टेस्ट' वर्ग स्थापित करते हैं जहां चर को पूर्णांक प्रकार के 'वैल' के रूप में घोषित किया जाता है। फिर, हमारे पास 'टेस्ट ()' कंस्ट्रक्टर फ़ंक्शन की एक परिभाषा है जो 'एन' वेरिएबल के साथ पारित की जाती है। फिर हम 'टेस्ट ()' कंस्ट्रक्टर फ़ंक्शन के भीतर 'ट्राई-कैच' ब्लॉक सेट करते हैं। ट्राई ब्लॉक को if() स्टेटमेंट के साथ कॉल किया जाता है। यदि 'एन' का मान शून्य के बराबर है, तो 'कैच' ब्लॉक अपवाद को पकड़ लेगा, और अपवाद संदेश प्रॉम्प्ट पर फेंक दिया जाएगा। जैसे ही हम इसे आरंभ करते हैं, 'n' का मान 'वैल' वेरिएबल में संग्रहीत हो जाता है।
उसके बाद, हम 'वैल' वेरिएबल में संग्रहीत मान दिखाने के लिए डिस्प्ले() फ़ंक्शन को कॉल करते हैं। इसके बाद, हमारे पास 'कैच' ब्लॉक की परिभाषा है जहां 'ट्राई' ब्लॉक द्वारा फेंके गए अपवाद को संभाला जाता है। अंत में, हम मुख्य() फ़ंक्शन को लागू करते हैं। जिसके अंदर, हम 'टेस्ट()' कंस्ट्रक्टर कहते हैं। कंस्ट्रक्टर तब ट्रिगर होता है जब 'टेस्ट ()' क्लास का ऑब्जेक्ट बनाया जाता है और '0' के मान के साथ निर्दिष्ट किया जाता है, जिस पर अपवाद फेंका जाता है।
उसके बाद, हम एक उदाहरण बनाने के लिए 'टेस्ट()' क्लास को फिर से कॉल करते हैं जिसे 1 के मान के साथ पास किया जाता है। यहां, कंस्ट्रक्टर कोई अपवाद नहीं फेंकेगा क्योंकि मान 0 के बराबर नहीं है। डिस्प्ले() फ़ंक्शन करेगा 'वैल' का मान निष्पादित करें और प्रिंट करें।
कंस्ट्रक्टर को कॉल करके कस्टम अपवाद को कंसोल पर डाला जाता है। साथ ही, जब शर्त पूरी हो जाती है, तो कंस्ट्रक्टर बिना किसी अपवाद के निष्पादन करता है।
उदाहरण 4: उपयोगकर्ता-परिभाषित कस्टम अपवाद बनाने का कार्यक्रम
यहां प्रोग्राम उस अपवाद को संभालता है और पकड़ता है जो प्रॉम्प्ट में पूछे जाने पर उपयोगकर्ता द्वारा परिभाषित किया गया है।
#शामिल करें#शामिल <अपवाद>
का उपयोग करते हुए नाम स्थान कक्षा ;
कक्षा मायडेमो : जनता अपवाद {
जनता :
कॉन्स्ट चार * क्या ( ) कॉन्स्ट फेंक ( )
{
वापस करना 'अपवाद! शून्य से विभाजित करने का प्रयास किया! \एन ' ;
}
} ;
int यहाँ मुख्य ( )
{
कोशिश
{
int यहाँ एन1, एन2 ;
अदालत << 'दो पूर्णांक दर्ज करें: \एन ' ;
खाना >> एन 1 >> एन 2 ;
अगर ( एन 2 == 0 )
{
मायडेमो n3 ;
फेंक n3 ;
}
अन्य
{
अदालत << 'एन1/एन2 = ' << एन 1 / एन 2 << अंतः ;
}
}
पकड़ना ( अपवाद & अतिरिक्त )
{
अदालत << अतिरिक्त. क्या ( ) ;
}
}
दिए गए कोड में, हम पहले 'MyDemo()' वर्ग को परिभाषित करते हैं जो अपवाद का आश्रित वर्ग है। उसके बाद, हम 'वर्चुअल' कीवर्ड के साथ सार्वजनिक क्या() फ़ंक्शन सेट करते हैं। जब थ्रो () फ़ंक्शन अपवाद फेंकता है तो प्रोग्राम में अपवाद का कारण जानने के लिए व्हाट () फ़ंक्शन को कॉल किया जाता है। फिर, हमारे पास एक मुख्य() फ़ंक्शन है जहां अपवाद का पता लगाने और उसे संभालने के लिए ट्राइ-कैच {} ब्लॉक को परिभाषित किया गया है। ट्राई {} ब्लॉक के भीतर, हम दो वेरिएबल्स, 'n1' और 'n2' घोषित करते हैं, जिनके मान 'cin' कमांड का उपयोग करके उपयोगकर्ता से लिए जाते हैं। जब प्रत्येक 'n1' और 'n2' वेरिएबल के विरुद्ध मान प्राप्त होते हैं, तो 'if' स्थिति यह जांच करेगी कि 'n2' वेरिएबल 0 के बराबर है या नहीं। यदि ऐसा है, तो एक अपवाद फेंक दिया जाता है या विभाजन परिणाम लौटा दिए जाते हैं। अंत में, हमारे पास एक कैच {} ब्लॉक है जो 'अपवाद' वर्ग के संदर्भ को उससे विरासत में मिले पैरामीटर के रूप में लेता है।
आउटपुट तब दिखता है जब शर्त पूरी नहीं होती है और प्रोग्राम बिना किसी अपवाद के निष्पादित होता है:
इसके अलावा, हम '0' के मान को 'n2' वेरिएबल में परिभाषित करते हैं ताकि यह दर्शाया जा सके कि प्रोग्राम में अपवाद कैसे फेंका और पकड़ा जाता है।
निष्कर्ष
अंत में, हमने C++ की महत्वपूर्ण अवधारणा का प्रदर्शन किया जो एक अपवाद है। एक अपवाद प्रोग्राम के नियमित निष्पादन में बाधा डालता है। इसके लिए, हमने प्रोग्राम में होने वाले अपवाद को संभालने के लिए 'थ्रो', 'ट्राई' और 'कैच' कीवर्ड का उपयोग किया। अपवाद को अलग ढंग से संभालने के लिए हमने पिछले उदाहरणों में इन कीवर्ड का उपयोग किया था।