ఉదాహరణ 1:
'iostream' ఇక్కడ చేర్చబడింది, అనేక విధులు ప్రకటించబడిన హెడర్ ఫైల్. మేము మా కోడ్‌లో ఈ హెడర్ ఫైల్‌లో ప్రకటించబడిన ఈ ఫంక్షన్‌లను ఉపయోగిస్తాము, కాబట్టి మేము ఈ హెడర్ ఫైల్‌ని చేర్చుతాము. దీని తర్వాత, 'సిన్' మరియు 'కౌట్' వంటి ఫంక్షన్‌లు కూడా నిర్వచించబడినందున ఇక్కడ ఉంచబడిన “std” మాకు ఉంది. మన కోడ్ ప్రారంభంలో “namespace std”ని జోడిస్తే, ఈ అన్ని ఫంక్షన్‌లతో “std” అని టైప్ చేయాల్సిన అవసరం లేదు. దీని తరువాత, 'ప్రధాన()' ఫంక్షన్ ఇక్కడ అమలు చేయబడుతుంది, ఇది C++ ప్రోగ్రామ్ యొక్క డ్రైవర్ కోడ్‌గా కూడా సూచించబడుతుంది.
అప్పుడు, మేము ఇక్కడ “try” కీవర్డ్‌ని ఉపయోగిస్తాము, దీనిలో “my_num1”ని “35” విలువతో ప్రారంభిస్తాము. ఇది ఇక్కడ 'int' డేటా టైప్ వేరియబుల్. ఇప్పుడు, మేము ఈ వేరియబుల్‌ను “if” లోపల ఉంచాము మరియు “my_num1” తప్పనిసరిగా “98” కంటే ఎక్కువగా లేదా సమానంగా ఉండాలి అని చెప్పే షరతును ఉంచుతాము. ఇచ్చిన షరతు సంతృప్తి చెందినట్లయితే, అది 'if' లోపల ముందుకు సాగుతుంది మరియు ఇక్కడ వ్రాసిన ప్రకటనను అమలు చేస్తుంది. మేము 'కౌట్'ని ఉపయోగిస్తాము మరియు పరిస్థితి సంతృప్తి చెందినప్పుడు ప్రదర్శించడానికి సందేశాన్ని ఇన్సర్ట్ చేస్తాము.
దీని తర్వాత, 'else'ని ఉంచిన తర్వాత మేము 'త్రో' కీవర్డ్‌ని ఉపయోగిస్తాము. ఈ “త్రో” కీవర్డ్‌లో, మనం “my_num1”ని పారామీటర్‌గా పాస్ చేస్తాము. మేము దీని క్రింద 'క్యాచ్' భాగాన్ని జోడిస్తాము. మేము “my_num2”ని “క్యాచ్()” పరామితిగా చొప్పించి, ఈ “క్యాచ్” భాగంలో మళ్లీ “కౌట్”ని ఉపయోగిస్తాము. 'ప్రయత్నించు' భాగంలో మినహాయింపు సంభవించినప్పుడు మాత్రమే ఈ భాగం అమలు చేయబడుతుంది.
కోడ్ 1:
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
ప్రయత్నించండి {
int నా_సంఖ్య1 = 35 ;
ఉంటే ( నా_సంఖ్య1 >= 98 ) {
కోట్ << 'ఇక్కడ యాక్సెస్ మంజూరు చేయబడింది.' ;
} లేకపోతే {
త్రో ( నా_సంఖ్య1 ) ;
}
}
క్యాచ్ ( int నా_సంఖ్య2 ) {
కోట్ << 'ఇక్కడ యాక్సెస్ నిరాకరించబడింది.' << endl ;
కోట్ << 'సంఖ్య ఇది:' << నా_సంఖ్య2 ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము నమోదు చేసిన సంఖ్య “35”, ఇది “98” కంటే తక్కువ. కాబట్టి, మినహాయింపు అక్కడ సంభవిస్తుంది మరియు 'క్యాచ్ ()' భాగం ప్రదర్శించబడుతుంది. 'ప్రయత్నించు' భాగానికి యాక్సెస్ నిరాకరించబడింది.
ఉదాహరణ 2:
మేము ఇక్కడ “iostream” హెడర్ ఫైల్‌ను మరియు “namespace std”ని ఉంచుతాము. దీని తరువాత, మేము 'డివిజన్()' ఫంక్షన్‌ను సృష్టిస్తాము, దీనిలో మేము 'int' డేటా రకం యొక్క 'ల్యూమరేటర్' మరియు 'డినామినేటర్' అనే రెండు పారామితులను ఉంచుతాము. మేము ఈ 'డివిజన్' ఫంక్షన్ యొక్క డేటా రకాన్ని 'డబుల్'కి సెట్ చేసాము.
దీని క్రింద, మేము “if()”ని జోడిస్తాము, దీనిలో హారం సున్నాకి సమానం అనే షరతును జోడిస్తాము. దీని తరువాత, మేము 'త్రో' కీవర్డ్‌ని ఉపయోగిస్తాము మరియు అక్కడ సందేశాన్ని టైప్ చేస్తాము. షరతు ప్రకారం ఈ కోడ్‌లో మినహాయింపు వచ్చినప్పుడు ఈ సందేశం అందించబడుతుంది. దీని క్రింద, మేము 'రిటర్న్' కీవర్డ్‌ని ఉపయోగిస్తాము, దీనిలో మేము 'ల్యూమరేటర్/డినామినేటర్'ని ఉంచుతాము. కాబట్టి, ఇది విభజన ఫలితాన్ని అందిస్తుంది. ఇప్పుడు, 'ప్రధాన ()' ఫంక్షన్ అంటారు.
దీని తరువాత, “num1” మరియు “num2” “int” వేరియబుల్స్‌గా ప్రారంభించబడతాయి మరియు వాటికి వరుసగా “89” మరియు “0” కేటాయించబడతాయి. అప్పుడు, మేము 'డబుల్' డేటా రకం యొక్క 'ఫలితాన్ని' ప్రారంభిస్తాము. ఇక్కడ, మేము 'ప్రయత్నించు' కీవర్డ్‌ని ఉపయోగిస్తాము. ఈ భాగంలో, మేము ఈ “ఫలితం” వేరియబుల్‌ని జోడిస్తాము మరియు ఈ వేరియబుల్‌కు “డివిజన్()” ఫంక్షన్‌ను కేటాయిస్తాము. మేము ఈ ఫంక్షన్‌కు రెండు పారామితులను పాస్ చేస్తాము: “num1” మరియు “num2”. దీని క్రింద, “డివిజన్()” ఫంక్షన్‌ని వర్తింపజేసిన తర్వాత మనకు లభించే “ఫలితాన్ని” ప్రదర్శిస్తాము. దీని తర్వాత, మేము గతంలో జోడించిన సందేశాన్ని ప్రదర్శించడానికి “క్యాచ్” మరియు “const char* msg”ని కూడా ఉపయోగిస్తాము.
కోడ్ 2:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
రెట్టింపు విభజన ( int న్యూమరేటర్, int హారం ) {
ఉంటే ( హారం == 0 ) {
త్రో 'సున్నా ద్వారా విభజించడం ఇక్కడ సాధ్యం కాదు!' ;
}
తిరిగి ( న్యూమరేటర్ / హారం ) ;
}
int ప్రధాన ( ) {
int సంఖ్య1 = 89 ;
int సంఖ్య2 = 0 ;
రెట్టింపు ఫలితం = 0 ;
ప్రయత్నించండి {
ఫలితం = విభజన ( సంఖ్య 1, సంఖ్య 2 ) ;
కోట్ << ఫలితం << endl ;
} క్యాచ్ ( స్థిరంగా చార్ * సందేశం ) {
cerr << సందేశం << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము మునుపు హారం వలె చొప్పించిన సంఖ్య “0”. కాబట్టి, మినహాయింపు కోడ్‌లో సంభవిస్తుంది మరియు అది ఇచ్చిన సందేశాన్ని ప్రదర్శిస్తుంది.
ఉదాహరణ 3:
ఇక్కడ “మల్టిప్లికేషన్()” ఫంక్షన్ క్రియేట్ చేయబడింది, దీనిలో మనం “విలువ” మరియు “గుణకం”ని “పూర్ణాంక” డేటా రకం యొక్క పారామీటర్‌లుగా ఉంచుతాము. అప్పుడు, మేము సున్నాకి సమానమైన గుణకం షరతును జోడించే “if”ని ఉపయోగిస్తాము. అప్పుడు, మనం స్టేట్‌మెంట్‌ను జోడించే చోట “త్రో” ఉంచబడుతుంది. అప్పుడు, మనం గతంలో ప్రకటించిన “విలువ * గుణకం” వేరియబుల్స్‌ను ఉంచే “రిటర్న్” ఉంది. కాబట్టి, ఇది గుణకార ఫలితాన్ని ఇక్కడ అందిస్తుంది.
దీని తరువాత, మేము 'ముఖ్య()' అని పిలుస్తాము, ఇక్కడ మనం '34' మరియు '0' విలువలతో 'పూర్ణాంక విలువ1' మరియు 'పూర్ణాంక విలువ2'ని ప్రకటిస్తాము. “int m_res” కూడా ప్రకటించబడింది మరియు ఇక్కడ “మల్టిప్లికేషన్()” ఫంక్షన్ అని పిలుస్తారు. ఈ ఫంక్షన్ చేసిన తర్వాత, ఫలితం ఇప్పుడు “m_res” వేరియబుల్‌లో సేవ్ చేయబడుతుంది మరియు ఆపై ప్రదర్శించబడుతుంది. తదనంతరం, మేము గతంలో 'త్రో' భాగంలో జోడించిన సందేశాన్ని ప్రదర్శించడానికి 'క్యాచ్' ఫంక్షన్‌ని ఉపయోగిస్తాము మరియు 'const char* msg'ని ఇన్సర్ట్ చేస్తాము.
కోడ్ 3:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
రెట్టింపు గుణకారం ( int విలువ , int గుణకం ) {
ఉంటే ( గుణకం == 0 ) {
త్రో 'మేము విలువను సున్నాతో గుణించము!' ;
}
తిరిగి ( విలువ * గుణకం ) ;
}
int ప్రధాన ( ) {
int విలువ1 = 3. 4 ;
int విలువ2 = 0 ;
int m_res ;
ప్రయత్నించండి {
m_res = గుణకారం ( విలువ1, విలువ2 ) ;
కోట్ << m_res << endl ;
} క్యాచ్ ( స్థిరంగా చార్ * సందేశం ) {
cerr << సందేశం << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్ :
మేము గతంలో నమోదు చేసిన విలువ గుణకం వలె “0”ని కలిగి ఉన్నందున, కోడ్‌కు మినహాయింపు ఉంది, దీని వలన నోటీసు ఇక్కడ ప్రదర్శించబడుతుంది.
ఉదాహరణ 4:
ఇక్కడ, మేము “మల్టిప్లై()” ఫంక్షన్‌ని నిర్మిస్తాము మరియు “int” డేటా రకం యొక్క పారామీటర్‌లుగా “number1” మరియు “number2”లో పాస్ చేస్తాము. తర్వాత, సున్నా కంటే తక్కువ లేదా సమానమైన గుణకం అయిన షరతును జోడించడానికి మేము 'if' ఆపరేటర్‌ని ఉపయోగిస్తాము. ఆ తర్వాత, 'త్రో' ఎక్కడ ఉండాలో అక్కడ స్టేట్‌మెంట్ జోడించబడుతుంది. గుణకారం ఫలితం 'రిటర్న్' విభాగంలో తిరిగి ఇవ్వబడుతుంది, ఇక్కడ మనం గతంలో ప్రకటించిన 'సంఖ్య1 * సంఖ్య2' వేరియబుల్‌ను చొప్పించాము.
తదనంతరం, మేము “ప్రధాన()” ఫంక్షన్‌ని అమలు చేస్తాము మరియు “34” మరియు “12” విలువలను వరుసగా “int newNumber1” మరియు “int newNumber2”కి కేటాయిస్తాము. ఇక్కడ, 'గుణకం()'ఫంక్షన్ 'int mResult' డిక్లరేషన్ తర్వాత పిలువబడుతుంది. ఇప్పుడు, ఈ ఫంక్షన్ యొక్క ఫలితం “mResult” వేరియబుల్‌లో నిల్వ చేయబడుతుంది మరియు కింది వాటిలో రెండర్ చేయబడుతుంది. మేము 'క్యాచ్' ఫంక్షన్‌ని ఉపయోగిస్తాము మరియు 'త్రో' విభాగంలో మనం వ్రాసిన సందేశాన్ని ప్రదర్శించడానికి 'const char* msg'ని జోడిస్తాము.
కోడ్ 4:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
రెట్టింపు గుణించాలి ( int సంఖ్య 1, int సంఖ్య 2 ) {
ఉంటే ( సంఖ్య 2 <= 0 ) {
త్రో 'మేము విలువను సున్నా లేదా ప్రతికూల విలువతో గుణించము!' ;
}
తిరిగి ( సంఖ్య 1 * సంఖ్య 2 ) ;
}
int ప్రధాన ( ) {
int కొత్తసంఖ్య1 = 3. 4 ;
int కొత్తసంఖ్య2 = 12 ;
int m ఫలితం ;
ప్రయత్నించండి {
m ఫలితం = గుణించాలి ( newNum1, newNum2 ) ;
కోట్ << 'గుణకారం యొక్క ఫలితం' << m ఫలితం << endl ;
}
క్యాచ్ ( స్థిరంగా చార్ * సందేశం ) {
cerr << సందేశం << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము జోడించే విలువ “12”, దానిపై మేము షరతును జోడిస్తాము. కాబట్టి, షరతు నిజం కానందున “మల్టిప్లై()” ఫంక్షన్ నిర్వహించబడుతుంది. గుణకారం యొక్క ఫలితం ప్రదర్శించబడుతుంది. 'ప్రయత్నించు' భాగం ఇక్కడ అమలు చేయబడింది.
ముగింపు
ఈ గైడ్‌లోని “ట్రై-క్యాచ్” కాన్సెప్ట్ మరియు కోడ్‌లు వివరంగా అధ్యయనం చేయబడ్డాయి. మేము ఈ “ట్రై-క్యాచ్” కాన్సెప్ట్‌ను క్షుణ్ణంగా అన్వేషించాము మరియు ఇది C++ ప్రోగ్రామింగ్‌లో ఎలా పని చేస్తుందో చూపించాము. మా ప్రత్యేక కోడ్‌ను వ్రాయడానికి అనుమతించే లోపం కనుగొనబడినప్పుడు “త్రో” పదం మినహాయింపును సృష్టిస్తుందని మేము నిర్వచించాము. “క్యాచ్” ఎక్స్‌ప్రెషన్‌ని ఉపయోగించి, “ప్రయత్నించండి” భాగంలో మినహాయింపు కనిపిస్తే, అమలు చేయవలసిన కోడ్ బ్లాక్‌ను మేము పేర్కొనవచ్చు.