C++ ప్రోగ్రామింగ్‌లో, మేము పరిస్థితులను తనిఖీ చేయవలసిన వివిధ పరిస్థితులు ఉన్నాయి. కొన్నిసార్లు, మేము ఏకకాలంలో అనేక షరతులను సంతృప్తిపరచవలసి ఉంటుంది. మేము దీని కోసం C++ ప్రోగ్రామింగ్‌లోని “నెస్టెడ్ ఇఫ్” కండిషన్‌ను ఉపయోగిస్తాము. మనం 'if' పరిస్థితిని ఇతర 'if' లోపల ఉంచినట్లయితే, అది 'nest if' అని చెప్పబడుతుంది. మొదటి “if” షరతు సంతృప్తి చెందినప్పుడు, మనం ఆ “if” లోపలికి వెళ్తాము, అక్కడ మనం మరొక “if”ని ఉంచుతాము. అప్పుడు, ఇది మొదటి 'if' కండిషన్‌లో ఉంచబడిన 'if' కండిషన్‌ను తనిఖీ చేస్తుంది మరియు మొదలైనవి. ఇది అన్ని షరతులు సంతృప్తి చెందినప్పుడు మనం 'if' లోపల ఉంచే ఫలితాన్ని అందిస్తుంది.
ఉదాహరణ 1:
మనం 'నెస్టెడ్ ఇఫ్'ని ఉపయోగించుకునే కొన్ని కోడ్‌లను చేద్దాం. C++ కోడ్‌ని ప్రారంభించడానికి, మేము ఇక్కడ “iostream” హెడర్ ఫైల్‌ను చేర్చి, ఆపై “std” నేమ్‌స్పేస్‌ని చేర్చుతాము. దీని తరువాత, మేము 'ప్రధాన()'డ్రైవర్ కోడ్‌ను ఉంచుతాము మరియు వరుసగా '20', '10' మరియు '2' విలువలతో 'n1', 'n2' మరియు 'n3' అనే మూడు వేరియబుల్‌లను ప్రారంభిస్తాము. అప్పుడు, మేము ఇక్కడ “if” కండిషన్‌ను ఉపయోగిస్తాము, దీనిలో “n1” “n2” కంటే ఎక్కువగా ఉందో లేదో తనిఖీ చేస్తాము. ఈ షరతు సంతృప్తి చెందితే, మేము ఈ 'if' లోపల ముందుకు వెళ్తాము, ఇక్కడ మేము మరొక 'if' షరతును జోడిస్తాము.
ఇప్పుడు, రెండవ “if” “n3” కంటే ఎక్కువ ఉన్న “n1” విలువలను తనిఖీ చేస్తుంది. ఈ “నెస్టెడ్ ఇఫ్” షరతు కూడా సంతృప్తి చెందితే, మేము “కౌట్” స్టేట్‌మెంట్‌ని ఉంచే దాని క్రింద ఉన్న స్టేట్‌మెంట్ అమలు చేయబడుతుంది. కాబట్టి, ఈ కోడ్‌లో “నెస్టెడ్ ఇఫ్” యొక్క రెండు షరతులు సంతృప్తి చెందితే అది ఆ స్టేట్‌మెంట్‌ను ప్రింట్ చేస్తుంది. షరతుల్లో ఏదైనా తప్పు అయితే, అది కన్సోల్‌లో ఎలాంటి సందేశాన్ని ప్రదర్శించదు.
కోడ్ 1:
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
మీరు n1 = ఇరవై , n2 = 10 , n3 = 2 ;
ఉంటే ( n1 > n2 ) {
ఉంటే ( n1 > n3 ) {
కోట్ << 'n1 అనేది అతిపెద్ద విలువలు' << n1 << endl;
}
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, ఇది కన్సోల్‌లోని స్టేట్‌మెంట్‌ను చూపుతుంది అంటే “నెస్టెడ్ ఇఫ్” యొక్క “ఇఫ్” షరతులు రెండూ నిజం. “నెస్టెడ్ ఇఫ్” లోపల మేము జోడించిన ప్రకటన కూడా ఇక్కడ రెండర్ చేయబడింది.
ఉదాహరణ 2:
C++ కోడ్‌ని ప్రారంభించడానికి “std” నేమ్‌స్పేస్ మరియు “iostream” హెడర్ ఫైల్ ఇక్కడ చేర్చబడ్డాయి. అప్పుడు “ప్రధాన()”డ్రైవర్ కోడ్ చొప్పించబడుతుంది మరియు మూడు వేరియబుల్స్, “var1”, “var2” మరియు “var3”, తదనుగుణంగా “8”, “91,” మరియు “32” విలువలతో ప్రారంభించబడతాయి.
తర్వాత, “val1” “val2” కంటే చిన్నదో కాదో నిర్ధారించడానికి “if” షరతును ఉపయోగిస్తాము. ఈ షరతు నెరవేరినట్లయితే, మేము 'if' షరతులో కొనసాగుతాము మరియు మరొక 'if' షరతును జోడిస్తాము. రెండవ “if” ఇప్పుడు “val1” విలువ “val3” కంటే చిన్నదిగా ఉందో లేదో తనిఖీ చేస్తుంది. ఈ “నెస్టెడ్ ఇఫ్” షరతు కూడా నెరవేరితే, “కౌట్” లోపల ఉంచబడిన స్టేట్‌మెంట్ కింది వాటిలో అమలు చేయబడుతుంది. అందువల్ల, ఈ కోడ్‌లో “నెస్టెడ్ ఇఫ్” షరతులు రెండూ కలిసినట్లయితే, అది ఆ స్టేట్‌మెంట్‌ను ప్రింట్ చేస్తుంది. పరిస్థితులు అవాస్తవమైతే కన్సోల్ ఎలాంటి సందేశాన్ని చూపదు.
కోడ్ 2:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
int var1 = 8 , var2 = 91 , var3 = 32 ;
ఉంటే ( var1 < var2 ) {
ఉంటే ( var1 < var3 ) {
కోట్ << 'var1 అనేది అతి చిన్న విలువలు' << var1 << endl;
}
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
“నెస్టెడ్ ఇఫ్”లో మేము జోడించిన ప్రకటన ఇప్పుడు ఇక్కడ రెండర్ చేయబడింది. కన్సోల్‌లోని సందేశం 'నెస్టెడ్ ఇఫ్' యొక్క 'if' షరతులు రెండూ నిజమని సూచిస్తున్నాయి.
ఉదాహరణ 3:
ఇక్కడ “main()”లో, మేము “x”, “y” మరియు “z” అనే వేరియబుల్స్‌ను వరుసగా “11”, “22” మరియు “33” విలువలతో ప్రారంభిస్తాము. అప్పుడు, మేము “if”ని ఉపయోగిస్తాము, దీనిలో మేము “x == 11” అనే కండిషన్‌ను ఉంచుతాము మరియు ఈ “if” లోపల మరొక “if”ని ఉంచుతాము, ఇది “nest if”ని “y == 22” జోడిస్తుంది. పరిస్థితి. మొదటి 'if' షరతు నెరవేరినప్పుడు మాత్రమే ఈ 'నెస్టెడ్ ఇఫ్' అమలు చేయబడుతుంది.
దీని తర్వాత, మేము మునుపు జోడించిన “if” రెండూ సంతృప్తి చెందినప్పుడు అమలు చేయబడే రెండవ “if” లోపల మరొక “if”ని ఉపయోగిస్తాము. మూడవ “if”లో “z == 33” షరతు ఉంది మరియు మేము చివరి “if” కండిషన్‌లో “cout”ని చేర్చుతాము. ఇది మూడు “ఉంటే” షరతులు నిజమైతే మాత్రమే అమలు అవుతుంది.
కోడ్ 3:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
int x = పదకొండు , y = 22 , z = 33 ;
ఉంటే ( x == పదకొండు ) {
ఉంటే ( మరియు == 22 ) {
ఉంటే ( == తో 33 ) {
కోట్ << 'ఏయ్! ఇక్కడ ఉంటే C++ నెస్ట్ చేయబడింది!!' << endl;
}
}
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ ఫలితం అన్ని 'నెస్టెడ్ ఇఫ్' షరతులు సంతృప్తి చెందాయని చూపిస్తుంది. చివరి 'if' లోపల స్టేట్‌మెంట్ ఇక్కడ ప్రదర్శించబడుతుంది. జాబితా చేయబడిన షరతుల్లో ఏదైనా తప్పు అయితే ఈ ప్రకటన ఇక్కడ కనిపించదు.
ఉదాహరణ 4:
“ch1”, “ch2” మరియు “ch3” వేరియబుల్స్ “main()” ఫంక్షన్‌ను ప్రారంభించిన తర్వాత “a”, “b” మరియు “z” అక్షరాలతో “char” డేటా రకంగా ప్రారంభించబడతాయి. తర్వాత, మేము అదనపు “ch2 == b” షరతుతో “ch1 == a” కండిషన్‌తో “if” స్టేట్‌మెంట్‌ను మరియు దాని లోపల మరొక “if”ని ఉపయోగిస్తాము (“nested if” అని సూచిస్తారు). దీనర్థం మొదటి 'if' షరతు నెరవేరినప్పుడు మాత్రమే ఈ 'నెస్టెడ్ ఇఫ్' అమలు చేయబడుతుంది.
తదనంతరం, మేము రెండవ 'if'లో అదనంగా 'if'ని ఉపయోగిస్తాము, ఇది గతంలో చొప్పించిన రెండు 'if' షరతుల సంతృప్తిపై నిర్వహించబడుతుంది. “ch3 == z” షరతు మూడవ “if”లో కనుగొనబడింది మరియు “cout” అనే పదం చివరి “if” కండిషన్‌లో ఉంది. అన్ని షరతులు నెరవేరినట్లయితే మాత్రమే ఇది పాస్ అవుతుంది.
కోడ్ 4:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
చార్ ch1 = 'a' , ch2 = 'బి' , ch3 = 'తో' ;
ఉంటే ( ch1 == 'a' ) {
ఉంటే ( ch2 == 'బి' ) {
ఉంటే ( ch3 == 'తో' ) {
కోట్ << 'ది C++ ప్రోగ్రామింగ్ నెస్ట్ అయితే..!!' << endl;
}
}
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
చివరి 'if' లోపల ఉన్న వాక్యం ఇక్కడ చూపబడింది, ఇది అన్ని 'నెస్టెడ్ ఇఫ్' షరతులు సంతృప్తి చెందాయని సూచిస్తుంది. షరతుల్లో ఏవైనా తప్పుగా ఉంటే ఈ ప్రకటన ఇక్కడ కనిపించదు.
ఉదాహరణ 5:
“ప్రధాన()” పద్ధతికి కాల్ చేసిన తర్వాత, “f1”, “f2” మరియు “f3” వేరియబుల్స్ “2.40”, “19.7” మరియు “43.1” విలువలతో “ఫ్లోట్” డేటా రకంగా ప్రారంభించబడతాయి. తర్వాత, మేము “f1 == 2.40” షరతుతో “if” స్టేట్‌మెంట్‌ని మరియు దాని లోపల “f2 == 19.7” కండిషన్‌తో మరొక “if” (“నెస్టెడ్ if” అని కూడా పిలుస్తారు) ఉపయోగిస్తాము. మొదటి 'if' షరతు నెరవేరితేనే ఈ 'నెస్టెడ్ if' నిర్వహించబడుతుందని ఇది సూచిస్తుంది.
తరువాత, మేము రెండవ 'if' లోపల మూడవ 'if'ని ఉపయోగిస్తాము, ఇది గతంలో జోడించిన 'if' షరతులు రెండూ నెరవేరినట్లయితే అమలు చేయబడుతుంది. మూడవ “if” కండిషన్‌లో “f3 == 9” కండిషన్ ఉంటుంది మరియు చివరి “if” కండిషన్‌లో “cout” ఉంటుంది. మూడు ఆవశ్యకాలను నెరవేర్చిన సందర్భంలో మాత్రమే ఈ “కౌట్” ప్రకటన అందించబడుతుంది. అప్పుడు, ఈ అన్ని 'if' షరతుల వెలుపల, 'if' షరతు నిజం కానప్పుడు రెండర్ చేయబడిన 'cout'ని కూడా మేము జోడిస్తాము.
కోడ్ 5:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
ఫ్లోట్ f1 = 2.40 , f2 = 19.7 , f3 = 43.1 ;
ఉంటే ( f1 == 2.40 ) {
ఉంటే ( f2 == 19.7 ) {
ఉంటే ( f3 == 9 ) {
కోట్ << 'పరిస్థితులు ఇక్కడ నిజమైతే అన్నీ గూడు కట్టుకున్నాయి!!' << endl;
}
}
}
కోట్ << 'సంతృప్తి చెందకపోతే గూడుకట్టిన పరిస్థితి..!!' << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, ఇది 'నెస్టెడ్ ఇఫ్' కండిషన్ వెలుపల మేము జోడించిన స్టేట్‌మెంట్‌ను ప్రదర్శిస్తుంది మరియు 'నెస్టెడ్ ఇఫ్' షరతు సంతృప్తి చెందలేదని చూపిస్తుంది.
ముగింపు
C++లోని “నెస్టెడ్ ఇఫ్” కాన్సెప్ట్ ఇక్కడ క్షుణ్ణంగా నేర్చుకుంది. మేము 'నెస్టెడ్ ఇఫ్' అంటే 'if' కండిషన్‌ను ఇతర 'if' కండిషన్‌లో ఉంచామని మేము అన్వేషించాము. మేము ఏకకాలంలో అనేక షరతులను నెరవేర్చాల్సిన ఈ 'నెస్టెడ్ ఇఫ్' కండిషన్‌ను ఉపయోగించాము. మేము మా C++ కోడ్‌లలో “నెస్టెడ్ ఇఫ్” కండిషన్‌ని ఉపయోగించిన కొన్ని ఉదాహరణలను అన్వేషించాము మరియు అది ఎలా పని చేస్తుందో వివరించాము.