ఉదాహరణ 1: C++లో అనుకూల మినహాయింపు తరగతిని సృష్టించడానికి ప్రోగ్రామ్
C++లో అనుకూల మినహాయింపు నిర్వహణ మరియు గుర్తింపును ప్రదర్శించడానికి ఈ సాధారణ ఉదాహరణ అమలు చేయబడింది.
## <మినహాయింపు> చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి డెమో మినహాయింపు : ప్రజా మినహాయింపు
{
వర్చువల్ స్థిరంగా చార్ * ఏమి ( ) స్థిరంగా త్రో ( )
{
తిరిగి 'క్యాచ్ కస్టమ్ మినహాయింపు' ;
}
} ;
int ప్రధాన ( )
{
డెమోఎక్సెప్షన్ dEx ;
ప్రయత్నించండి
{
త్రో dEx ;
}
క్యాచ్ ( మినహాయింపు & తప్ప )
{
కోట్ << తప్ప. ఏమి ( ) << endl ;
}
తిరిగి 0 ;
}
మేము 'iostream' మరియు 'exception'తో సహా కోడ్‌లో హెడర్ ఫైల్‌ను నిర్వచించాము. 'iostream' ప్రత్యేకంగా ఇన్‌పుట్ మరియు అవుట్‌పుట్ స్ట్రీమ్ కోసం పిలువబడుతుంది, అయితే మినహాయింపును నిర్వహించడానికి 'మినహాయింపు' లైబ్రరీని పిలుస్తారు. దీని తరువాత, మేము C++ యొక్క 'మినహాయింపు' తరగతి నుండి తీసుకోబడిన 'డెమోఎక్సెప్షన్' తరగతిని సృష్టిస్తాము. ఇక్కడ, మినహాయింపుతో లింక్ చేయబడిన దోష సందేశం యొక్క ఫలితాలను ప్రదర్శించే const char*ని అందించడానికి ఉపయోగించే వర్చువల్ what() ఫంక్షన్‌ని మేము సెట్ చేసాము.
అప్పుడు, మేము 'డెమోఎక్సెప్షన్' క్లాస్ యొక్క 'dEx' ఆబ్జెక్ట్‌ను సృష్టించే ప్రధాన() ఫంక్షన్‌ను అమలు చేస్తాము. ఆ తర్వాత, మనకు 'ప్రయత్నించండి' బ్లాక్ డెఫినిషన్ ఉంది, అది ఎదురైతే మినహాయింపును విసిరివేస్తుంది. ఇక్కడ, మేము 'dEx' వస్తువును విసిరాము.
తరువాత, మేము మినహాయింపును పట్టుకోవడానికి మరియు దానిని నిర్వహించడానికి 'క్యాచ్' బ్లాక్ను సెట్ చేస్తాము. మేము దాని నుండి ఉద్భవించిన మినహాయింపును పట్టుకోవడానికి తరగతి మినహాయింపు యొక్క సూచనను పారామీటర్‌గా పాస్ చేస్తాము. “క్యాచ్” బ్లాక్ లోపల, కన్సోల్‌లో మినహాయింపు సందేశాన్ని పొందడానికి “తప్ప”పై what() ఫంక్షన్‌ని పిలుస్తాము.
ఇచ్చిన ప్రోగ్రామ్‌ను అమలు చేసిన తర్వాత, అనుకూల మినహాయింపు సందేశం క్యాచ్ చేయబడింది మరియు కన్సోల్‌పై వేయబడుతుంది:
ఉదాహరణ 2: రెండు తరగతులను ఉపయోగించి అనుకూల మినహాయింపును సృష్టించే ప్రోగ్రామ్
బహుళ తరగతులను నిర్వచించడం ద్వారా స్వతంత్రంగా నిర్వహించగలిగే బహుళ మినహాయింపులతో వ్యవహరించడాన్ని ప్రోగ్రామ్ నొక్కి చెబుతుంది.
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి మూల్యాంకనం 1 { } ;
తరగతి మూల్యాంకనం 2 { } ;
int ప్రధాన ( ) {
ప్రయత్నించండి {
త్రో మూల్యాంకనం 1 ( ) ;
}
క్యాచ్ ( మూల్యాంకనం 1 ఇ ) {
కోట్ << 'మూల్యాంకనం1 మినహాయింపు క్యాచ్!' << endl ;
}
ప్రయత్నించండి {
త్రో మూల్యాంకనం 2 ( ) ;
}
క్యాచ్ ( మూల్యాంకనం 2 ఇ ) {
కోట్ << 'మూల్యాంకనం 2 మినహాయింపు క్యాచ్!' << endl ;
}
తిరిగి 0 ;
}
ఇచ్చిన కోడ్‌లో, 'మూల్యాంకనం1' మరియు 'మూల్యాంకనం2' అనే రెండు తరగతుల నిర్వచనం మాకు ఉంది, అవి ఇప్పుడు ఖాళీగా ఉన్నాయి. ఆ తరువాత, మేము ప్రోగ్రామ్ యొక్క ప్రధాన () ఫంక్షన్‌ను నిర్వహిస్తాము. ఇక్కడ, మేము 'ఎవాల్యుయేషన్1()' క్లాస్ యొక్క ఉదాహరణను విసిరేందుకు 'త్రో' కీవర్డ్ ఉపయోగించబడే ట్రై{} బ్లాక్‌ని సెట్ చేసాము. ఈ “ప్రయత్నించండి” బ్లాక్‌లోని ప్రోగ్రామ్‌లో ఏదైనా మినహాయింపు వస్తే “మూల్యాంకనం1” మినహాయింపు విసిరివేయబడుతుందని ఇది సూచిస్తుంది. ఆ తర్వాత, మనకు క్యాచ్{} బ్లాక్ ఉంది, ఇక్కడ మినహాయింపు క్యాచ్ చేయబడి, మినహాయింపు సందేశాన్ని ప్రదర్శిస్తుంది.
అదేవిధంగా, “మూల్యాంకనం2” తరగతి కోసం మేము మరొక ప్రయత్నం{} బ్లాక్‌ని నిర్వచించాము. ఆ ప్రయత్నం{} బ్లాక్ లోపల, మేము “మూల్యాంకనం2” తరగతికి సంబంధించిన ఉదాహరణను త్రోసివేస్తాము. ఇక్కడ లోపం సంభవించినట్లయితే ఇది 'మూల్యాంకనం2' మినహాయింపును విసురుతుంది. అప్పుడు, ఈ బ్లాక్‌లో మినహాయింపు క్యాచ్ చేయబడితే, “cout” ఆదేశాన్ని ఉపయోగించి మినహాయింపు సందేశాన్ని ప్రదర్శించడానికి మేము క్యాచ్{} బ్లాక్‌ని పిలుస్తాము.
వేర్వేరు 'ట్రై-క్యాచ్' బ్లాక్‌ల యొక్క రెండు మినహాయింపులు రెండు వేర్వేరు తరగతులచే నిర్వహించబడే కన్సోల్‌లో వేయబడతాయి.
ఉదాహరణ 3: కన్స్ట్రక్టర్‌తో అనుకూల మినహాయింపును సృష్టించే ప్రోగ్రామ్
మినహాయింపును నిర్వహించడానికి ప్రోగ్రామ్ కన్స్ట్రక్టర్‌ను ఉపయోగిస్తుంది. మేము కన్స్ట్రక్టర్ నుండి విలువలను పొందలేనప్పటికీ, 'ట్రై-క్యాచ్' బ్లాక్‌ని ఉపయోగించి మనం దీన్ని సాధించవచ్చు.
#ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి పరీక్ష {
int విలువ ;
ప్రజా :
పరీక్ష ( int n )
{
ప్రయత్నించండి {
ఉంటే ( n == 0 )
విలువ = n ;
ప్రదర్శన ( ) ;
}
క్యాచ్ ( స్థిరంగా చార్ * ఎక్స్ ) {
కోట్ << 'మినహాయింపు కనుగొనబడింది \n ' ;
కోట్ << ఎక్స్ << endl ;
}
}
శూన్యం ప్రదర్శన ( )
{
కోట్ << 'విలువ =' << విలువ << endl ;
}
} ;
int ప్రధాన ( )
{
పరీక్ష ( 0 ) ;
కోట్ << 'మళ్ళీ ఉదాహరణను సృష్టిస్తోంది \n ' ;
పరీక్ష ( 1 ) ;
}
ఇచ్చిన కోడ్‌లో, మేము 'పరీక్ష' తరగతిని ఏర్పాటు చేస్తాము, ఇక్కడ వేరియబుల్ టైప్ పూర్ణాంకం యొక్క 'val'గా ప్రకటించబడుతుంది. అప్పుడు, మనకు “Test()” కన్స్ట్రక్టర్ ఫంక్షన్ యొక్క నిర్వచనం ఉంది, ఇది “n” వేరియబుల్‌తో ఆమోదించబడుతుంది. మేము 'టెస్ట్()' కన్స్ట్రక్టర్ ఫంక్షన్‌లో 'ట్రై-క్యాచ్' బ్లాక్‌ని సెట్ చేసాము. if() స్టేట్‌మెంట్‌తో ట్రై బ్లాక్ అంటారు. “n” విలువ సున్నాకి సమానం అయితే, “క్యాచ్” బ్లాక్ మినహాయింపును క్యాచ్ చేస్తుంది మరియు మినహాయింపు సందేశం ప్రాంప్ట్‌లో విసిరివేయబడుతుంది. “n” విలువ మనం ప్రారంభించినప్పుడు “val” వేరియబుల్‌లో నిల్వ చేయబడుతుంది.
ఆ తర్వాత, “val” వేరియబుల్‌లో నిల్వ చేయబడిన విలువను చూపించడానికి డిస్ప్లే() ఫంక్షన్‌ని పిలుస్తాము. తరువాత, మేము 'క్యాచ్' బ్లాక్ యొక్క నిర్వచనాన్ని కలిగి ఉన్నాము, ఇక్కడ 'ప్రయత్నించు' బ్లాక్ ద్వారా విసిరిన మినహాయింపు నిర్వహించబడుతుంది. చివరగా, మేము ప్రధాన () ఫంక్షన్‌ను అమలు చేస్తాము. దీని లోపల, మేము “టెస్ట్()”కన్స్ట్రక్టర్ అని పిలుస్తాము. “పరీక్ష()” తరగతి యొక్క వస్తువు సృష్టించబడినప్పుడు మరియు మినహాయింపు విసిరిన “0” విలువతో నిర్దేశించినప్పుడు కన్స్ట్రక్టర్ ప్రేరేపించబడుతుంది.
ఆ తర్వాత, 1 విలువతో ఉత్తీర్ణత సాధించిన ఉదాహరణను సృష్టించడానికి మేము మళ్లీ “పరీక్ష()” క్లాస్‌ని పిలుస్తాము. ఇక్కడ, విలువ 0కి సమానం కానందున కన్స్ట్రక్టర్ ఎటువంటి మినహాయింపును ఇవ్వరు. డిస్ప్లే() ఫంక్షన్ అవుతుంది 'val' విలువను అమలు చేసి ముద్రించండి.
కస్టమ్ మినహాయింపు కన్సోల్‌లో కన్‌స్ట్రక్టర్‌కు కాల్ చేయడం ద్వారా విసిరివేయబడుతుంది. అలాగే, షరతు సంతృప్తి చెందినప్పుడు, కన్స్ట్రక్టర్ ఎటువంటి మినహాయింపు లేకుండా అమలు చేస్తాడు.
ఉదాహరణ 4: వినియోగదారు నిర్వచించిన అనుకూల మినహాయింపును సృష్టించే ప్రోగ్రామ్
ప్రాంప్ట్‌లో అడిగినప్పుడు వినియోగదారు నిర్వచించిన మినహాయింపును ఇక్కడ ప్రోగ్రామ్ నిర్వహిస్తుంది మరియు క్యాచ్ చేస్తుంది.
## <మినహాయింపు> చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి MyDemo : ప్రజా మినహాయింపు {
ప్రజా :
స్థిరంగా చార్ * ఏమి ( ) స్థిరంగా త్రో ( )
{
తిరిగి 'మినహాయింపు! సున్నాతో విభజించడానికి ప్రయత్నించారు.! \n ' ;
}
} ;
int ప్రధాన ( )
{
ప్రయత్నించండి
{
int n1, n2 ;
కోట్ << 'రెండు పూర్ణాంకాలను నమోదు చేయండి: \n ' ;
ఆహారపు >> n1 >> n2 ;
ఉంటే ( n2 == 0 )
{
MyDemo n3 ;
త్రో n3 ;
}
లేకపోతే
{
కోట్ << 'n1/n2 =' << n1 / n2 << endl ;
}
}
క్యాచ్ ( మినహాయింపు & exc )
{
కోట్ << exc. ఏమి ( ) ;
}
}
ఇచ్చిన కోడ్‌లో, మినహాయింపుపై ఆధారపడిన తరగతి అయిన “MyDemo()” తరగతిని మేము మొదట నిర్వచించాము. ఆ తర్వాత, మేము 'వర్చువల్' కీవర్డ్‌తో పబ్లిక్ what() ఫంక్షన్‌ని సెట్ చేస్తాము. త్రో() ఫంక్షన్ మినహాయింపును విసిరినప్పుడు ప్రోగ్రామ్‌లో మినహాయింపు యొక్క కారణాన్ని పొందడానికి what() ఫంక్షన్ అంటారు. ఆపై, మినహాయింపును గుర్తించి, నిర్వహించడానికి ట్రై-క్యాచ్{} బ్లాక్‌లు నిర్వచించబడే ప్రధాన() ఫంక్షన్‌ని మేము కలిగి ఉన్నాము. ప్రయత్నించండి{} బ్లాక్‌లో, మేము “n1” మరియు “n2” అనే రెండు వేరియబుల్‌లను ప్రకటిస్తాము, దీని విలువలు “cin” ఆదేశాన్ని ఉపయోగించి వినియోగదారు నుండి తీసుకోబడతాయి. ప్రతి “n1” మరియు “n2” వేరియబుల్స్‌కు వ్యతిరేకంగా విలువలు వచ్చినప్పుడు, “if” కండిషన్ “n2” వేరియబుల్ 0కి సమానంగా ఉందో లేదో తనిఖీ చేస్తుంది. అలా అయితే, మినహాయింపు ఇవ్వబడుతుంది లేదా విభజన ఫలితాలు అందించబడతాయి. చివరగా, మనకు క్యాచ్{} బ్లాక్ ఉంది, ఇది 'మినహాయింపు' తరగతి యొక్క సూచనను దాని నుండి వారసత్వంగా పొందిన పారామీటర్‌గా తీసుకుంటుంది.
అవుట్‌పుట్ షరతు పూర్తికానప్పుడు మరియు మినహాయింపు లేకుండా ప్రోగ్రామ్ అమలు చేయబడినప్పుడు చూపిస్తుంది:
అలాగే, ప్రోగ్రామ్‌లో మినహాయింపు ఎలా విసిరివేయబడిందో మరియు క్యాచ్ చేయబడిందో సూచించడానికి మేము “0” విలువను “n2” వేరియబుల్‌కు నిర్వచించాము.
ముగింపు
ముగింపులో, మేము మినహాయింపు అయిన C++ యొక్క ముఖ్యమైన భావనను ప్రదర్శించాము. ఒక మినహాయింపు ప్రోగ్రామ్ యొక్క సాధారణ అమలును అడ్డుకుంటుంది. దీని కోసం, ప్రోగ్రామ్‌లో జరిగే మినహాయింపును నిర్వహించడానికి మేము 'త్రో', 'ట్రై' మరియు 'క్యాచ్' కీవర్డ్‌లను ఉపయోగించాము. మినహాయింపును విభిన్నంగా నిర్వహించడానికి మేము మునుపటి ఉదాహరణలలో ఈ కీలకపదాలను ఉపయోగించాము.