C++ अपवाद प्रबंधन: ट्राई, कैच, थ्रो उदाहरण

यदि कोड के उस भाग में कोई असाधारण स्थिति उत्पन्न होती है, तो अपवाद फेंक दिया जाएगा। इसके बाद, अपवाद हैंडलर प्रोग्राम का नियंत्रण अपने हाथ में ले लेगा।

यदि कोई असाधारण परिस्थिति नहीं होती है, तो कोड सामान्य रूप से निष्पादित होगा। हैंडलर्स को अनदेखा कर दिया जाएगा।

इस में C++ ट्यूटोरियल में आप सीखेंगे:

अपवाद प्रबंधन क्यों?

यहाँ, अपवाद हैंडलिंग का उपयोग करने के कारण दिए गए हैं C++:

• आप अपने त्रुटि प्रबंधन कोड को अपने सामान्य कोड से अलग कर देंगे। कोड अधिक पठनीय और रखरखाव में आसान होगा।
• फ़ंक्शन अपने द्वारा चुने गए अपवादों को संभाल सकते हैं। भले ही कोई फ़ंक्शन कई अपवादों को फेंकता हो, लेकिन यह केवल कुछ को ही संभालेगा। कॉलर अनकैच्ड अपवादों को संभालेगा।

अपवाद हैंडलिंग कीवर्ड

अपवाद प्रबंधन C++ इन तीन कीवर्ड के इर्द-गिर्द घूमता है:

• फेंकना- जब कोई प्रोग्राम किसी समस्या का सामना करता है, तो वह अपवाद फेंकता है। थ्रो कीवर्ड प्रोग्राम को थ्रो करने में मदद करता है।
• पकड़- एक प्रोग्राम अपवाद को पकड़ने के लिए अपवाद हैंडलर का उपयोग करता है। इसे प्रोग्राम के उस भाग में जोड़ा जाता है जहाँ आपको समस्या को संभालने की आवश्यकता होती है। यह catch कीवर्ड का उपयोग करके किया जाता है।
• कोशिश- try ब्लॉक उस कोड ब्लॉक की पहचान करता है जिसके लिए कुछ अपवाद सक्रिय किए जाएँगे। इसके बाद एक/अधिक catch ब्लॉक होने चाहिए।

मान लीजिए कि कोई कोड ब्लॉक अपवाद उत्पन्न करेगा। अपवाद को try और catch कीवर्ड का उपयोग करके विधि द्वारा पकड़ा जाएगा। try/catch ब्लॉक को उस कोड को घेरना चाहिए जो अपवाद उत्पन्न कर सकता है। ऐसे कोड को संरक्षित कोड के रूप में जाना जाता है।

वाक्य - विन्यास

Try/catch इस सिंटैक्स को अपनाता है:

try {
   // the protected code
} catch( Exception_Name exception1 ) {
   // catch block
} catch( Exception_Name exception2 ) {
   // catch block
} catch( Exception_Name exceptionN ) {
   // catch block
}

• यद्यपि हमारे पास एक try कथन है, हमारे पास अनेक catch कथन हो सकते हैं।
• ExceptionName पकड़े जाने वाले अपवाद का नाम है।
• अपवादों को संदर्भित करने के लिए exception1, exception2, और exceptionN आपके परिभाषित नाम हैं।

उदाहरण 1:

#include<iostream>
#include<vector>
using namespace std;

int main() {
	vector<int> vec;
	vec.push_back(0);	
	vec.push_back(1);	
	// access the third element, which doesn't exist
	try
	{
		vec.at(2);		
	}
	catch (exception& ex)
	{
		cout << "Exception occurred!" << endl;
	}
	return 0;
}

आउटपुट:

कोड का स्क्रीनशॉट यहां दिया गया है:

कोड स्पष्टीकरण:

1. प्रोग्राम में iostream हेडर फ़ाइल को शामिल करें ताकि इसका उपयोग किया जा सके कार्यों.
2. प्रोग्राम के कार्यों का उपयोग करने के लिए वेक्टर हेडर फ़ाइल को प्रोग्राम में शामिल करें।
3. प्रोग्राम में std नामस्थान को बिना कॉल किए उसके क्लासों में शामिल करें।
4. main() फ़ंक्शन को कॉल करें। प्रोग्राम लॉजिक को इसके बॉडी में जोड़ा जाना चाहिए।
5. पूर्णांक डेटा संग्रहीत करने के लिए vec नामक एक वेक्टर बनाएं।
6. vec नामक वेक्टर में तत्व 0 जोड़ें।
7. vec नामक वेक्टर में तत्व 1 जोड़ें।
8. एक टिप्पणी। इसे छोड़ दिया जाएगा C++ संकलक.
9. अपवाद को पकड़ने के लिए try कथन का उपयोग करें। { try/catch ब्लॉक के मुख्य भाग की शुरुआत को चिह्नित करता है। मुख्य भाग में जोड़ा गया कोड संरक्षित कोड बन जाएगा।
10. vec नामक वेक्टर के इंडेक्स 2 (तीसरे तत्व) पर संग्रहीत तत्व तक पहुँचने का प्रयास करें। यह तत्व मौजूद नहीं है।
11. try/catch ब्लॉक के मुख्य भाग का अंत.
12. अपवाद को पकड़ें। लौटाया गया त्रुटि संदेश चर ex में संग्रहीत किया जाएगा।
13. यदि अपवाद पकड़ा जाता है तो कंसोल पर कुछ संदेश प्रिंट करें।
14. कैच ब्लॉक के मुख्य भाग का अंत.
15. प्रोग्राम को सफल निष्पादन पर एक मान लौटाना चाहिए।
16. main() फ़ंक्शन बॉडी का अंत.

उदाहरण 2:

#include <iostream>
using namespace std;
double zeroDivision(int x, int y) {

	if (y == 0) {
		throw "Division by Zero!";
	}
	return (x / y);
}

int main() {
	int a = 11;
	int b = 0;
	double c = 0;

	try {
		c = zeroDivision(a, b);
		cout << c << endl;
	}
	catch (const char* message) {
		cerr << message << endl;
	}
	return 0;
}

आउटपुट:

कोड का स्क्रीनशॉट यहां दिया गया है:

कोड स्पष्टीकरण:

1. प्रोग्राम के कार्यों का उपयोग करने के लिए प्रोग्राम में iostream हेडर फ़ाइल शामिल करें।
2. प्रोग्राम में std नामस्थान को बिना कॉल किए उसके क्लासों में शामिल करें।
3. zeroDivision नामक एक फ़ंक्शन बनाएँ जो दो पूर्णांक तर्क, x, और y लेता है। फ़ंक्शन को एक डबल परिणाम वापस करना चाहिए।
4. यह जाँचने के लिए कि क्या चर तर्क y का मान 0 है, if कथन का उपयोग करें। { if बॉडी की शुरुआत को चिह्नित करता है।
5. यदि y 0 है तो लौटाया/फेंका जाने वाला संदेश.
6. if कथन के मुख्य भाग का अंत.
7. zeroDivision फ़ंक्शन को x/y का मान लौटाना चाहिए।
8. zeroDivision फ़ंक्शन के मुख्य भाग का अंत.
9. main() विधि को कॉल करें। { इस विधि की शुरुआत को चिह्नित करता है।
10. एक पूर्णांक चर घोषित करें और उसे मान 11 निर्दिष्ट करें।
11. एक पूर्णांक चर b घोषित करें और उसे मान 0 निर्दिष्ट करें।
12. एक डबल वेरिएबल c घोषित करें और उसे मान 0 निर्दिष्ट करें।
13. अपवाद को पकड़ने के लिए try कथन का उपयोग करें। { try/catch ब्लॉक के मुख्य भाग की शुरुआत को चिह्नित करता है। मुख्य भाग में जोड़ा गया कोड संरक्षित कोड बन जाएगा।
14. zeroDivision फ़ंक्शन को कॉल करें और तर्क a और b को पास करें, अर्थात, 11 और 0. इस ऑपरेशन का परिणाम चर c में संग्रहीत किया जाएगा।
15. कंसोल पर वेरिएबल c का मान प्रिंट करें।
16. try/catch ब्लॉक के मुख्य भाग का अंत.
17. अपवाद को पकड़ें। लौटाया गया त्रुटि संदेश वेरिएबल संदेश में संग्रहीत किया जाएगा।
18. कंसोल पर लौटाए गए त्रुटि संदेश को प्रिंट करें।
19. कैच ब्लॉक के मुख्य भाग का अंत.
20. प्रोग्राम को सफल निष्पादन पर एक मान लौटाना चाहिए।
21. main() फ़ंक्शन बॉडी का अंत.

C++ मानक अपवाद

C++ में परिभाषित मानक अपवादों की एक सूची के साथ आता है वर्ग। इनका वर्णन नीचे किया गया है:

अपवाद	विवरण
std::अपवाद	यह एक अपवाद है और सभी मानक का मूल वर्ग है C++ अपवाद नहीं।
std:: Bad_alloc	यह अपवाद new कीवर्ड द्वारा उत्पन्न होता है।
std::bad_cast	यह dynamic_cast द्वारा उत्पन्न अपवाद है।
std::bad_exception	अप्रत्याशित अपवादों से निपटने के लिए एक उपयोगी उपकरण C++ कार्यक्रम.
std::bad_typeid	typeid द्वारा फेंका गया अपवाद.
std::logic_error	यह अपवाद सैद्धांतिक रूप से कोड पढ़कर पता लगाया जा सकता है।
std::डोमेन_त्रुटि	यह गणितीय रूप से अमान्य डोमेन का उपयोग करने के बाद उत्पन्न अपवाद है।
std::अमान्य_तर्क	अमान्य तर्कों का उपयोग करने के कारण अपवाद उत्पन्न हुआ.
std::लंबाई_त्रुटि	एक बड़ा std::string बनाने के बाद एक अपवाद उत्पन्न हुआ.
std::आउट_ऑफ_रेंज	विधि द्वारा फेंका गया।
std::रनटाइम_त्रुटि	यह एक अपवाद है जिसे कोड पढ़कर नहीं पहचाना जा सकता।
std::ओवरफ़्लो_त्रुटि	यह अपवाद गणितीय अतिप्रवाह की घटना के बाद उत्पन्न होता है।
std::रेंज_त्रुटि	यह अपवाद तब उत्पन्न होता है जब आप सीमा से बाहर का मान संग्रहीत करने का प्रयास करते हैं।
std::अंडरफ़्लो_त्रुटि	गणितीय अधःप्रवाह की घटना के बाद उत्पन्न अपवाद.

उपयोगकर्ता-परिभाषित अपवाद

RSI C++ std::exception क्लास हमें उन ऑब्जेक्ट को परिभाषित करने की अनुमति देता है जिन्हें अपवाद के रूप में फेंका जा सकता है। इस क्लास को में परिभाषित किया गया है हेडर। यह क्लास हमें एक वर्चुअल सदस्य फ़ंक्शन प्रदान करता है जिसका नाम है what.

यह फ़ंक्शन char * प्रकार का शून्य-समाप्त वर्ण अनुक्रम लौटाता है। अपवाद विवरण के लिए हम इसे व्युत्पन्न वर्गों में अधिलेखित कर सकते हैं।

उदाहरण:

#include <iostream>
#include <exception>
using namespace std;

class newException : public exception
{
	virtual const char* what() const throw()
	{
		return "newException occurred";
	}
} newex;

int main() {

	try {
		throw newex;
		}
	catch (exception& ex) {
		cout << ex.what() << '\n';
	}
	return 0;	
}

आउटपुट:

कोड का स्क्रीनशॉट यहां दिया गया है:

कोड स्पष्टीकरण:

1. हमारे प्रोग्राम में iostream हेडर फ़ाइल शामिल करें। हम बिना किसी त्रुटि के इसके फ़ंक्शन का उपयोग करेंगे।
2. हमारे प्रोग्राम में अपवाद हेडर फ़ाइल शामिल करें। हम इसके फ़ंक्शन का उपयोग बिना किसी त्रुटि के करेंगे।
3. अपने प्रोग्राम में std नामस्थान को शामिल करें ताकि उसे कॉल किए बिना उसकी कक्षाओं का उपयोग किया जा सके।
4. newException नाम से एक नया क्लास बनाएँ। यह क्लास अपवाद क्लास को इनहेरिट करता है C++.
5. कक्षा की शुरुआत.
6. अपवाद हेडर फ़ाइल में परिभाषित वर्चुअल सदस्य फ़ंक्शन what() को ओवरराइट करें। फिर हम अपने स्वयं के अपवाद, नए अपवाद का वर्णन करेंगे।
7. नये अपवाद की परिभाषा प्रारंभ करें.
8. नया अपवाद पकड़े जाने पर लौटाया जाने वाला संदेश.
9. नये अपवाद की परिभाषा का अंत.
10. क्लास newException के बॉडी का अंत। newex वह नाम है जिसका उपयोग हमारे नए अपवाद को पकड़ने के लिए किया जाएगा, जिसके बाद newException को कॉल किया जाएगा।
11. main() फ़ंक्शन को कॉल करें। प्रोग्राम लॉजिक को इसके बॉडी में जोड़ा जाना चाहिए। { इसके बॉडी की शुरुआत को दर्शाता है।
12. उस कोड को चिह्नित करने के लिए try कथन का उपयोग करें जिसके भीतर हमें अपवाद को चिह्नित करना है। { try/catch ब्लॉक के मुख्य भाग की शुरुआत को चिह्नित करता है। इससे घिरा कोड सुरक्षित हो जाएगा।
13. यदि newex अपवाद पकड़ा जाए तो उसे फेंक दें।
14. प्रयत्न निकाय का अंत.
15. अपवाद को पकड़ने के लिए कैच स्टेटमेंट का उपयोग करें। अपवाद त्रुटि संदेश चर ex में संग्रहीत किया जाएगा।
16. कंसोल पर अपवाद त्रुटि संदेश प्रिंट करें.
17. कैच कथन के मुख्य भाग का अंत.
18. यदि प्रोग्राम सफलतापूर्वक निष्पादित होता है तो उसे एक मान लौटाना चाहिए।
19. main() फ़ंक्शन के मुख्य भाग का अंत.

सारांश

• अपवाद प्रबंधन के साथ C++, आप रनटाइम त्रुटियों को संभाल सकते हैं.
• रनटाइम त्रुटियाँ वे त्रुटियाँ हैं जो प्रोग्राम निष्पादन के दौरान होती हैं।
• अपवाद प्रबंधन आपके प्रोग्राम में किसी भी अप्रत्याशित परिस्थिति को संभालने में आपकी सहायता करता है।
• जब अप्रत्याशित परिस्थिति उत्पन्न होती है, तो प्रोग्राम नियंत्रण संचालकों को हस्तांतरित कर दिया जाता है।
• किसी अपवाद को पकड़ने के लिए, आप कोड का एक भाग try-catch ब्लॉक के अंतर्गत रखते हैं।
• थ्रो कीवर्ड प्रोग्राम को अपवादों को फेंकने में मदद करता है, जिससे प्रोग्राम को समस्या से निपटने में मदद मिलती है।
• Try कीवर्ड उस कोड ब्लॉक की पहचान करने में मदद करता है जिसके लिए कुछ अपवाद सक्रिय किए जाएंगे।
• हम अपने अपवादों को परिभाषित करने के लिए अपवाद हेडर फ़ाइल के what() फ़ंक्शन को अधिलेखित कर सकते हैं।