C++లో మినహాయింపులను సులభంగా ఎలా నిర్వహించాలి
C++లో మినహాయింపు హ్యాండ్లింగ్ అనేది చెల్లని ఇన్‌పుట్‌లను నిర్వహించడం, డివిజన్ ఆపరేషన్‌లలో సంఖ్యను సున్నాతో విభజించడం మరియు మరెన్నో వంటి రన్-టైమ్ లోపాలను గుర్తించడం మరియు వాటిని సమర్థవంతంగా నిర్వహించడం వంటి యంత్రాంగాన్ని సూచిస్తుంది.
C++లో మినహాయింపు నిర్వహణలో మూడు కీలకపదాలు ఉంటాయి: ప్రయత్నించండి, విసిరేయండి మరియు పట్టుకోండి. కోడ్‌లో మినహాయింపును పెంచే కోడ్ బ్లాక్‌ను నిర్వచించడానికి ట్రై స్టేట్‌మెంట్ వినియోగదారుని అనుమతిస్తుంది. ప్రయత్నించండి కీవర్డ్ కింద బ్లాక్‌ని తనిఖీ చేసిన తర్వాత గుర్తించినట్లయితే త్రో కీవర్డ్ మినహాయింపును విసురుతుంది. క్యాచ్ కీవర్డ్ ట్రై బ్లాక్‌లో గమనించిన మినహాయింపును నిర్వహించగల కోడ్ బ్లాక్‌ను కలిగి ఉంది.
ఉదాహరణ 1: విభజన సమయంలో మినహాయింపు నిర్వహణ
విభజన సమయంలో మినహాయింపులను తనిఖీ చేయడానికి కోడ్ వ్రాయబడింది.
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
రెట్టింపు గణము, హారం, భాగము ;
కోట్ << 'ల్యూమరేటర్ విలువను నమోదు చేయండి:' ;
ఆహారపు >> న్యూమరేటర్ ;
కోట్ <> హారం ;
ప్రయత్నించండి {
ఉంటే ( హారం == 0 )
త్రో 0 ;
విభజన = న్యూమరేటర్ / హారం ;
కోట్ << న్యూమరేటర్ << '/' << హారం << ' = ' << విభజన << endl ;
}
క్యాచ్ ( int సంఖ్య_మినహాయింపు ) {
కోట్ << 'లోపం! డివైజర్ కాకూడదు ' << సంఖ్య_మినహాయింపు << endl ;
}
తిరిగి 0 ;
}
ఈ ప్రోగ్రామ్‌లో, వినియోగదారు ప్రధాన() విభాగంలో ప్రకటించిన న్యూమరేటర్ మరియు హారం యొక్క విలువను ఇన్‌పుట్ చేస్తారు. ట్రై బ్లాక్‌లో, హారం సున్నా కాదా అనే మినహాయింపును తనిఖీ చేయడానికి if స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. హారం 0గా గుర్తించబడితే విభజన సున్నా డివైజర్‌తో నిర్వహించబడదు కాబట్టి, అది మినహాయింపును త్రోసివేస్తుంది మరియు క్యాచ్ బ్లాక్ లోపం వాదనను అందిస్తుంది, లేకపోతే సాధారణ విభజన ఆపరేషన్ చేయబడుతుంది.
వినియోగదారు హారంలో న్యూమరేటర్ 42 మరియు 0ని ఇన్‌పుట్ చేస్తారు, ఇది మినహాయింపును ఇస్తుంది, కాబట్టి ప్రోగ్రామ్ లోపం వాదనను అందిస్తుంది.
వినియోగదారు 42 మరియు 2 లను హారం వలె ఇన్‌పుట్ చేస్తారు, మినహాయింపు ఏదీ కనుగొనబడలేదు, విభజన తర్వాత ఫలితం తిరిగి వస్తుంది.
ఉదాహరణ 2 వయస్సును తనిఖీ చేయడానికి మినహాయింపు నిర్వహణ
ఈ ప్రోగ్రామ్ వినియోగదారు వయస్సులో మినహాయింపులను తనిఖీ చేస్తుంది.
#ఉపయోగించి నేమ్‌స్పేస్ std ;
/*
ఇక్కడ, మేము వ్యక్తి వయస్సు 18 కంటే తక్కువ ఉంటే మినహాయింపు (వయస్సు మినహాయింపు) వేయాలనుకుంటున్నాము.
*/
int ప్రధాన ( )
{
// ట్రై బ్లాక్‌లో వయస్సు 18 కంటే ఎక్కువ ఉంటే తనిఖీ చేస్తోంది.
ప్రయత్నించండి
{
int వయస్సు ;
కోట్ << 'యాక్సెస్ చేయడానికి మీ వయస్సును నమోదు చేయండి:' ;
ఆహారపు >> వయస్సు ;
ఉంటే ( వయస్సు >= 18 )
{
కోట్ << 'యాక్సెస్ మంజూరు చేయబడింది.' ;
}
// వయస్సు 18 ఏళ్లలోపు ఉంటే కస్టమ్ మినహాయింపు విసిరివేయబడుతుంది.
లేకపోతే
{
త్రో ( వయస్సు ) ;
}
}
// విసిరిన మినహాయింపును పట్టుకోవడం మరియు కావలసిన అవుట్‌పుట్‌ను ప్రదర్శించడం (యాక్సెస్ నిరాకరించబడింది!)
క్యాచ్ ( int x )
{
కోట్ << 'యాక్సెస్ నిరాకరించబడింది! మీకు తక్కువ వయస్సు ఉంది.' << endl ;
}
తిరిగి 0 ;
}
ఈ ప్రోగ్రామ్‌లో, పూర్ణాంక విలువతో వేరియబుల్ నిర్వచించబడుతుంది. వినియోగదారు వయస్సుని ఇన్‌పుట్ చేయమని మరియు వినియోగదారు వయస్సు 18 కంటే ఎక్కువ లేదా సమానంగా ఉన్నట్లయితే బ్లాక్ చెక్‌లను ప్రయత్నించమని అడగబడతారు. ఇది నిజం కాకపోతే, అది మినహాయింపును ఇస్తుంది మరియు మినహాయింపు బ్లాక్ యాక్సెస్ తిరస్కరించబడిందని తిరిగి ఇస్తుంది! వాదన. లేకపోతే, యాక్సెస్ మంజూరు చేయబడుతుంది.
ఈ వయస్సు 18 ఏళ్లలోపు ఉన్నందున, యాక్సెస్ మంజూరును తనిఖీ చేయడానికి వినియోగదారు వయస్సు 12 అని ఇన్‌పుట్ చేస్తారు, కాబట్టి యాక్సెస్ తిరస్కరించబడిన వాదన తిరిగి ఇవ్వబడుతుంది.
వినియోగదారు 20 ఏళ్ల వయస్సును ఇన్‌పుట్ చేస్తారు, ఇది 18 ఏళ్ల కంటే ఎక్కువ, కాబట్టి వినియోగదారుకు యాక్సెస్ మంజూరు చేయబడుతుంది.
గమనిక : ప్రోగ్రామ్‌లో క్యాచ్ బ్లాక్ లేనట్లయితే, ప్రోగ్రామ్ అసాధారణంగా ప్రవర్తిస్తుంది మరియు మినహాయింపుల విషయంలో ఊహించని విధంగా ముగించబడుతుంది.
ముగింపు
C++లో మినహాయింపు నిర్వహణ అనేది రన్-టైమ్ లోపాలను గుర్తించడం మరియు వాటిని సమర్ధవంతంగా నిర్వహించడం అనే యంత్రాంగాన్ని సూచిస్తుంది. ఇందులో ట్రై, త్రో మరియు క్యాచ్ అనే మూడు కీలకపదాలు ఉంటాయి. ట్రై బ్లాక్‌లోని కోడ్ కోసం మినహాయింపు తనిఖీ చేయబడుతుంది, త్రో కీవర్డ్ దొరికితే మినహాయింపును విసురుతుంది మరియు క్యాచ్ బ్లాక్ ట్రై బ్లాక్ కోసం విసిరిన మినహాయింపును నిర్వహిస్తుంది. మినహాయింపులను నిర్వహించడం వలన రన్-టైమ్ లోపాలను నివారించడం ద్వారా వినియోగదారు అనుభవాన్ని సున్నితంగా మరియు గొప్పగా చేస్తుంది.