ఉదాహరణ 1:
“iostream” అనేది ఇక్కడ చేర్చబడిన హెడర్ ఫైల్, దీని వలన మేము మా కోడ్‌లోని “cin” లేదా “cout” పద్ధతులను ఉపయోగించుకోవచ్చు, ఎందుకంటే దానిలో రెండు పద్ధతులు ప్రకటించబడ్డాయి. ఈ హెడర్ ఫైల్‌లో “cerr” ఆబ్జెక్ట్ కూడా ప్రకటించబడింది. అప్పుడు, మనకు “std నేమ్‌స్పేస్” ఉంటుంది. ఇప్పుడు, మేము ఈ “std”ని ప్రతి ఫంక్షన్‌తో స్వతంత్రంగా జోడించాల్సిన అవసరం లేదు.
అప్పుడు, 'ప్రధాన()' ఇక్కడ సూచించబడుతుంది. దీని క్రింద, మేము “cerr” ఆబ్జెక్ట్‌ని ఉపయోగిస్తాము మరియు మేము కన్సోల్‌లో ప్రదర్శించాలనుకుంటున్న దోష సందేశాన్ని ఉంచుతాము. మేము 'ఇక్కడ ఒక లోపం సంభవించింది!' అని టైప్ చేస్తాము. చొప్పించే చిహ్నాలను ఉంచిన తర్వాత ఈ “cerr”లో సందేశం పంపండి. మేము ఈ ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు, ఇచ్చిన సందేశం “కౌట్” ఉపయోగించకుండా ప్రదర్శించబడుతుంది.
కోడ్ 1:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
cerr << 'ఇక్కడ ఒక లోపం సంభవించింది!' << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
“cerr <<”ని ఉంచిన తర్వాత మనం టైప్ చేసే సందేశం ఇప్పుడు క్రింది వాటిలో ప్రదర్శించబడే ఈ ఫలితంలో ప్రదర్శించబడుతుంది:
ఉదాహరణ 2:
“iostream” హెడర్ ఫైల్‌లో “cin” మరియు “cout” పద్ధతులు అలాగే “cerr” రెండూ డిక్లేర్ చేయబడినందున, మేము వాటిని మా కోడ్‌లో ఉపయోగించుకోవడానికి హెడర్ ఫైల్‌ని ఇక్కడ జోడిస్తాము. ఆ తర్వాత, మనకు “std నేమ్‌స్పేస్” ఉంటుంది. దీని క్రింద, 'ప్రధాన ()' అని పిలుస్తారు. మేము “స్ట్రింగ్” డేటా రకం యొక్క “error_str[]”ని ప్రారంభిస్తాము మరియు “error_str[]”కి సందేశాన్ని కేటాయిస్తాము. అప్పుడు, మేము దోష సందేశాన్ని ఉంచే 'cerr' ఆబ్జెక్ట్‌ని ఉపయోగిస్తాము మరియు ఈ 'error_str'ని పాస్ చేస్తాము. కాబట్టి, మేము ఈ ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు, ఇది రెండు సందేశాలను అందిస్తుంది.
కోడ్ 2:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
చార్ లోపం_str [ ] = 'మేము ఇక్కడ స్ట్రింగ్ చదవలేము!' ;
cerr << 'తప్పు జరిగింది :' << లోపం_str << endl ;
}
అవుట్‌పుట్:
“cerr <<” అని టైప్ చేసిన తర్వాత మనం టైప్ చేసే టెక్స్ట్ ఇప్పుడు ఫలితంలో అలాగే “error_str”లో జోడించిన మెసేజ్‌లో కనిపిస్తుంది. ఫలితం క్రింది వాటిలో కూడా చూపబడింది:
ఉదాహరణ 3:
హెడర్ ఫైల్‌ను చేర్చి, ఆపై “std” నేమ్‌స్పేస్‌ను ఉంచిన తర్వాత, మేము “main()” పద్ధతిని పిలుస్తాము. దీని తర్వాత, “NumOfLine” పూర్ణాంక వేరియబుల్ ఇక్కడ ప్రకటించబడింది మరియు “__LINE__”తో ప్రారంభించబడుతుంది. ఈ “__LINE__” దోష సందేశాలను రూపొందిస్తుంది. దీని క్రింద, మేము “cerr” ఆబ్జెక్ట్‌ని ఉపయోగిస్తాము మరియు మేము వినియోగదారుకు ప్రదర్శించాలనుకుంటున్న దోష సందేశాన్ని ఉంచుతాము. మేము 'NumOfLine' వేరియబుల్‌ను కూడా ఉంచుతాము, ఇది కోడ్‌లో లోపం సంభవించే లైన్ నంబర్‌ను చూపుతుంది.
కోడ్ 3:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int NumOfline = __LINE__ ;
cerr << 'ఇక్కడ లైన్‌లో లోపం సంభవించింది:' << NumOfline ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, మేము కోడ్ యొక్క నాల్గవ పంక్తిలో '__LINE__'ని జోడించినప్పుడు '4' లైన్‌లో లోపం సంభవించినట్లు చూపిస్తుంది. ఈ సందేశం C++లోని “cerr” ఆబ్జెక్ట్ సహాయంతో ఇక్కడ ప్రదర్శించబడుతుంది.
ఉదాహరణ 4:
మేము 'fstream' అనే మరో హెడర్ ఫైల్‌ని చేర్చాము. ఈ “fstream” హెడర్ ఫైల్ “ఆఫ్‌స్ట్రీమ్” అలాగే “ifstream” కలయిక అయినందున ఫైల్‌ను చదవడానికి, వ్రాయడానికి లేదా సృష్టించడానికి C++లో ఉపయోగించబడుతుంది. ఇప్పుడు, “std నేమ్‌స్పేస్” జోడించి, “main()”ని ప్రారంభించిన తర్వాత, మేము “new_file” వేరియబుల్‌తో “fstream”ని ఉపయోగిస్తాము.
అప్పుడు, మేము ఇక్కడ “new_file”తో “open()” ఫంక్షన్‌ని ఉపయోగిస్తాము మరియు ఫైల్ పేరును పారామీటర్‌గా పాస్ చేస్తాము. ఫైల్ పేరు “myTextFile.txt” మేము తెరవాలనుకుంటున్నాము. దీని క్రింద, 'new_file' వేరియబుల్‌ను పాస్ చేయడానికి మేము 'if'ని ఉపయోగిస్తాము. ఇప్పుడు, ఫైల్ ఇక్కడ తెరిస్తే, “if” తర్వాత స్టేట్‌మెంట్ రెండర్ చేయబడుతుంది. లేకపోతే, ఎర్రర్ మెసేజ్‌ని చూపించడానికి మనం “cerr” ఆబ్జెక్ట్‌ని జోడించే చోట “else” తర్వాత స్టేట్‌మెంట్ రెండర్ చేయబడుతుంది.
కోడ్ 4:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
fstream new_file ;
new_file. తెరవండి ( 'myTextFile.txt' ) ;
ఉంటే ( new_file ) {
కోట్ << 'ఫైల్ ఇక్కడ విజయవంతంగా తెరవబడింది!' ;
}
లేకపోతే {
cerr << 'ఇక్కడ ఫైల్‌ని తెరవడంలో లోపం సంభవించింది!' ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము గతంలో అందించిన ఫైల్‌ను తెరవలేము. ఇక్కడ, ఇది “cerr” ఆబ్జెక్ట్ తర్వాత మనం చొప్పించిన దోష సందేశాన్ని ప్రదర్శిస్తుంది.
ఉదాహరణ 5:
ఇక్కడ, మేము మరొక ఫైల్‌ను తెరవాలనుకుంటున్నాము. కాబట్టి, మేము హెడర్ ఫైల్‌లు మరియు “std” నేమ్‌స్పేస్ రెండింటినీ జోడిస్తాము. ఇప్పుడు, మనము “main()” అని పిలుస్తాము, ఆపై “t_file” వేరియబుల్‌తో “fstream”ని ఉపయోగిస్తాము. తర్వాత, మేము ఈ సందర్భంలో “new_file”తో “open()” ఫంక్షన్‌ని ఉపయోగిస్తాము మరియు ఫైల్ పేరును ఆర్గ్యుమెంట్‌గా అందిస్తాము. మనం తెరవాలనుకుంటున్న ఫైల్‌ని “New.txt” అంటారు. మేము “t_file” వేరియబుల్‌ను దాటి “if” స్టేట్‌మెంట్‌ను ఉపయోగిస్తాము. ఇప్పుడు, ఫైల్ తెరిస్తే, 'if'ని అనుసరించే లైన్ రెండర్ చేయబడుతుంది. కాకపోతే, దోష సందేశాన్ని ప్రదర్శించడానికి మేము “cerr” ఆబ్జెక్ట్‌ని జోడించిన “else”ని అనుసరించే స్టేట్‌మెంట్ రెండర్ చేయబడుతుంది.
కోడ్ 5:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
fstream t_file ;
t_file. తెరవండి ( 'New.txt' ) ;
ఉంటే ( t_file ) {
కోట్ << 'ఫైల్ ఇక్కడ తెరవబడింది!' ;
}
లేకపోతే {
cerr << 'తప్పు జరిగింది!' ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము అందించిన ఫైల్ తెరవబడదు. కాబట్టి, “cerr” ఆబ్జెక్ట్ తర్వాత మేము జోడించిన దోష సందేశం క్రింది వాటిలో ప్రదర్శించబడుతుంది:
ఉదాహరణ 6:
మేము ఇక్కడ 'మినహాయింపు' హెడర్ ఫైల్‌ని జోడిస్తాము, ఇది మా కోడ్‌లో సంభవించే లోపాల కోసం తనిఖీ చేయడానికి ఉపయోగించబడుతుంది. కింది వాటిలో, మేము “6” పరిమాణంలో “new_array” పేరుతో పూర్ణాంకాల రకం శ్రేణిని ప్రారంభిస్తాము. అప్పుడు, మేము 'int' వేరియబుల్ యొక్క 'new_index'ని సెట్ చేసాము మరియు ఇక్కడ '7'ని కేటాయించాము. ఇప్పుడు, మేము “new_size” వేరియబుల్‌ని కూడా ప్రారంభించాము మరియు “new_size” వేరియబుల్‌కు “*(&new_arr + 1) – new_arr”ని కేటాయిస్తాము.
దీని తర్వాత, మేము లోపాలను తనిఖీ చేయడానికి మరియు దోష సందేశాన్ని విసిరేందుకు ఉపయోగించే 'ప్రయత్నించు', 'త్రో' మరియు 'క్యాచ్'లను ఉపయోగిస్తాము. మేము 'త్రో' కీవర్డ్ తర్వాత జోడించిన దోష సందేశాన్ని చూపే 'రంగు' వస్తువును ఉపయోగిస్తాము.
కోడ్ 6:
## <మినహాయింపు> చేర్చండి
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int కొత్త_అర్ [ 6 ] = { 1 , 9 , 4 , 3 , 8 , 7 } ;
int కొత్త_సూచిక = 7 ;
int కొత్త_పరిమాణం = * ( & కొత్త_అర్ + 1 ) - కొత్త_అర్ ;
ప్రయత్నించండి {
ఉంటే ( కొత్త_సూచిక < 0 || కొత్త_సూచిక >= కొత్త_పరిమాణం ) త్రో ( 'ఇండెక్స్ శ్రేణిలో లేదు. ఇక్కడ పరిధి వెలుపల ఉంది' ) ;
లేకపోతే
కోట్ << కొత్త_అర్ [ కొత్త_సూచిక ] ;
}
క్యాచ్ ( స్థిరంగా చార్ * తప్పు ) {
cerr << తప్పు ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, ఇది 'ఇండెక్స్' పరిధి వెలుపల ఉందని చూపే ఒక దోష సందేశాన్ని అందిస్తుంది మరియు 'cerr' ఆబ్జెక్ట్‌ని ఉపయోగించడం ద్వారా మేము ఈ లోపాన్ని పొందుతాము.
ఉదాహరణ 7:
ఇక్కడ, మేము సంఖ్యను సున్నాతో భాగించినప్పుడు సంభవించే లోపాన్ని తనిఖీ చేస్తాము. మేము “d()”ఫంక్షన్‌ని సృష్టిస్తాము, దీనిలో మేము “int” డేటా రకం “a1” మరియు “a2” యొక్క రెండు వేరియబుల్‌లను పాస్ చేస్తాము. దీని క్రింద, మనం “a2==0” కండిషన్‌ను పాస్ చేసే “if”ని జోడిస్తాము. “a2” విలువ సున్నా అయితే, “త్రో” తర్వాత మనం ఉంచే సందేశం అమలు చేయబడుతుంది, ఇది కోడ్‌లో “cerr” ఆబ్జెక్ట్‌ను ఉంచడం ద్వారా మనకు లభిస్తుంది.
దీని తర్వాత, 'a2' విలువ సున్నా కానట్లయితే, విభజన యొక్క సమాధానాన్ని అందించే 'రిటర్న్'ని ఉంచుతాము. ఇప్పుడు, మేము “main()”ని అమలు చేస్తాము మరియు “int” వేరియబుల్‌గా ప్రారంభించిన తర్వాత “x”కి “87”ని కేటాయిస్తాము. దీని తర్వాత, మేము '0'తో 'b' మరియు 'd_res' వేరియబుల్స్‌ను కూడా ప్రారంభిస్తాము. ఇక్కడ, మేము లోపాన్ని పట్టుకునే “ప్రయత్నించు” మరియు “క్యాచ్”ని ఉంచుతాము మరియు “త్రో” కీవర్డ్ తర్వాత మేము జోడించిన దోష సందేశాన్ని “cerr” విసిరివేస్తుంది.
కోడ్ 7:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int నా_డివిజన్ ( int a1 , int a2 ) {
ఉంటే ( a2 == 0 ) {
త్రో 'సున్నా ద్వారా విభజన సాధ్యం కాదు!' ;
}
తిరిగి ( a1 / a2 ) ;
}
int ప్రధాన ( ) {
int x = 87 ;
int మరియు = 0 ;
int d_ఏమీ లేదు = 0 ;
ప్రయత్నించండి {
d_ఏమీ లేదు = నా_డివిజన్ ( x , మరియు ) ;
కోట్ << d_ఏమీ లేదు << endl ;
} క్యాచ్ ( స్థిరంగా చార్ * సందేశం ) {
cerr << సందేశం << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, దోష సందేశం కనిపిస్తుంది అంటే మనం సంఖ్యను '0' ద్వారా విభజించాలనుకుంటున్నాము, ఇది అసాధ్యం.
ముగింపు
'cerr' వస్తువు ఇక్కడ వివరంగా అధ్యయనం చేయబడింది. C++ ప్రోగ్రామింగ్‌లో దోష సందేశాన్ని ప్రదర్శించడంలో “cerr” ఆబ్జెక్ట్ ఎలా సహాయపడుతుందో మేము నిర్వచించాము. లోపం సంభవించే అనేక షరతులను ఉంచిన అనేక ఉదాహరణలను మేము అన్వేషించాము. మేము ట్రై-క్యాచ్ పద్ధతిని ఉంచిన తర్వాత మరియు ఫైల్ ఓపెనింగ్ కోడ్‌లో “cerr” ఆబ్జెక్ట్‌ను కూడా ఉపయోగించాము. మేము కోడ్‌ని అలాగే “cerr” దోష సందేశాన్ని ప్రదర్శించే ఫలితాన్ని చూపించాము.