C++లో, మేము కోడ్ బ్లాక్‌ను పునరావృతం చేయవలసి వచ్చినప్పుడు, మేము ఆ స్థలంలో “లూప్‌లను” ఉపయోగిస్తాము. ఇది ఒకే కోడ్‌ని మళ్లీ మళ్లీ టైప్ చేయడానికి మన సమయాన్ని తగ్గిస్తుంది. మేము కోడ్ విభాగాన్ని పునరావృతం చేయడానికి C++లో “లూప్‌లు” ఉపయోగిస్తాము. 'లూప్స్' పద్ధతి C++ ప్రోగ్రామింగ్‌లో చాలా సమర్థవంతమైన మరియు సమయాన్ని ఆదా చేసే ప్రక్రియ. 'ఫర్ లూప్', 'వైల్ లూప్', 'డూ-వైల్ లూప్' మరియు 'నెస్టెడ్ లూప్' వంటి C++ భాష ద్వారా అందించబడిన వివిధ రకాల లూప్‌లు ఉన్నాయి. 'నెస్టెడ్ లూప్' అంటే మనం ఒకదానికొకటి లోపల రెండు లూప్‌లను ఉంచుతాము లేదా ఒక లూప్‌లో మరొక లూప్ ఉందని కూడా చెప్పవచ్చు.
ఇక్కడ, మేము ఈ గైడ్‌లో C++లోని “నెస్టెడ్” లూప్‌లను మాత్రమే అన్వేషిస్తాము. మేము ఈ 'నెస్టెడ్' లూప్‌లను ఉపయోగించే కోడ్‌లు క్రింది విధంగా ఉన్నాయి:
ఉదాహరణ 1:
మేము C++లో పని చేస్తున్నప్పుడు తప్పనిసరిగా హెడర్ ఫైల్‌ను చేర్చాలి, కాబట్టి మేము ఇక్కడ “iostream” హెడర్ ఫైల్‌ను చేర్చుతాము. హెడర్ ఫైల్‌లు చేర్చబడ్డాయి, తద్వారా వాటిలో ప్రకటించబడిన మా కోడ్‌లోని పద్ధతులు లేదా ఫంక్షన్‌లను మనం ఉపయోగించుకోవచ్చు. దీని కింద, మేము “std” నేమ్‌స్పేస్‌ని జోడించి, ఆ స్థలంలో “main()” పద్ధతిని పిలుస్తాము.
అప్పుడు, మేము 'ఫర్' లూప్‌ని ఉపయోగించుకుంటాము, దీనిలో మనం మరొక 'ఫర్' లూప్‌ను కూడా ఉంచుతాము; దీనిని 'నెస్టెడ్ ఫర్ లూప్' అంటారు. మొదటి “ఫర్” లూప్‌లో, మేము “1”తో “int” డేటా రకం యొక్క “a” వేరియబుల్‌ని ప్రారంభిస్తాము. షరతు కూడా ఇక్కడ ఉంచబడింది, ఇది “a <= 3” అని చెబుతుంది, ఆపై “a” విలువలో “++a” పెరుగుతుంది. ఇక్కడ కొంత వచనాన్ని ప్రింట్ చేయడానికి మేము ఈ 'ఫర్' లూప్ క్రింద 'కౌట్'ని ఉంచుతాము. తదుపరి “ఫర్” లూప్‌లో, మేము “1” విలువతో “int” డేటా రకం యొక్క “b” వేరియబుల్‌ని ప్రారంభిస్తాము. మేము ఇక్కడ జోడించే షరతు “b <= 4” మరియు అది కూడా పెంచబడింది. మేము ఈ 'నెస్టెడ్ ఫర్' క్రింద మరొక 'కౌట్'ని ఉంచుతాము.
కోడ్ 1:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
కోసం ( int a = 1 ; a < = 3 ; ++ఎ ) {
కోట్ << 'మై ఫర్ లూప్:' << a << endl;
కోసం ( int b = 1 ; బి < = 4 ; ++బి ) {
కోట్ << ' నా నెస్టెడ్ లూప్: ' << బి << endl;
}
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇచ్చిన “నెస్టెడ్ లూప్” ఫలితం ఇప్పుడు ఇక్కడ రెండర్ చేయబడింది. మేము దాని పరిస్థితిని “3”కి సర్దుబాటు చేసినప్పుడు మొదటి “కౌట్” స్టేట్‌మెంట్ మూడుసార్లు కనిపిస్తుంది మరియు కోడ్‌లో దాని కండిషన్‌ను “4”కి సర్దుబాటు చేసినప్పుడు రెండవ “కౌట్” స్టేట్‌మెంట్ నాలుగుసార్లు కనిపిస్తుంది.
ఉదాహరణ 2:
'ప్రధాన ()' ఫంక్షన్ అంటారు. అప్పుడు, మేము వరుసగా “2” మరియు “7” విలువలతో “myNewWeek” మరియు “weekDays” వేరియబుల్‌లను ప్రారంభిస్తాము. కింది వాటిలో మనం ఉపయోగించే “నెస్టెడ్ ఫర్ లూప్” రెండు “ఫర్” లూప్‌లతో కూడి ఉంటుంది, వీటిని మనం ఒకదానికొకటి ఉంచుతాము. “i <= myNewWeek” షరతు మరియు “i” విలువలో “++i” ఇంక్రిమెంట్ ఇక్కడ మొదటి “for” లూప్‌లో ఉంచబడ్డాయి, ఇక్కడ మనం “int” డేటా రకం యొక్క “i” వేరియబుల్‌ని ప్రారంభించాము '1'. ఇక్కడ కొంత వచనాన్ని ప్రింట్ చేయడానికి మేము ఈ 'ఫర్' లూప్ క్రింద 'కౌట్'ని ఉంచుతాము. కింది 'ఫర్' లూప్‌లో '1' విలువతో 'int' డేటా రకం యొక్క 'j' అనే వేరియబుల్‌ని మేము ప్రారంభిస్తాము.
ఇక్కడ, మేము “j <= వారపు రోజులు” షరతును జోడించి, దానిని పెంచుతాము. మరొక 'కౌట్' ఈ 'నెస్టెడ్ ఫర్' లూప్ క్రింద ఉంచబడింది.
కోడ్ 2:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
int myNewWeek = 2 , వారం రోజులు = 7 ;
కోసం ( int i = 1 ; i < = myNewWeek; ++i ) {
కోట్ << 'వారం:' << i << endl;
కోసం ( int j = 1 ; జె < = వారం రోజులు; ++j ) {
కోట్ << ' వారం రోజు: ' << జె << endl;
}
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇంతకు ముందు పేర్కొన్న “నెస్టెడ్ లూప్” ఇప్పుడు ఈ విధంగా ప్రదర్శించబడుతుంది. కోడ్ ఇప్పుడు మొదటి “కౌట్” స్టేట్‌మెంట్ యొక్క మూడు సందర్భాలను చూపుతుంది (దీని పరిస్థితి “2”కి పరిష్కరించబడింది) మరియు రెండవ “కౌట్” స్టేట్‌మెంట్ యొక్క నాలుగు సందర్భాలు (దీని పరిస్థితి “7”కి స్థిరంగా ఉంటుంది).
ఉదాహరణ 3:
ఇక్కడ, మేము '@' చిహ్నాన్ని 'నెస్టెడ్ ఫర్' లూప్‌తో త్రిభుజాకార నమూనాలో ప్రదర్శించాలనుకుంటున్నాము. దీని కోసం, మేము మొదటి “ఫర్” లూప్‌ను ఉంచుతాము మరియు “1” విలువతో “int i” వేరియబుల్‌ను ప్రారంభించిన తర్వాత దాని పరిస్థితిని “i <= 6”కి సర్దుబాటు చేస్తాము.
అప్పుడు, మేము 'i' విలువలో ఇంక్రిమెంటేషన్‌ను కూడా వర్తింపజేస్తాము. దీని కింద, మనకు మరొక “ఫర్” ఉంది, దీనిలో “j” వేరియబుల్‌ను “1” విలువతో “int”గా ప్రారంభించిన తర్వాత “j <= i” అని చెప్పే మరొక షరతును ఉంచాము. ఈ “j” వేరియబుల్ విలువ కూడా ఇక్కడ పెంచబడింది. ఇప్పుడు, '@' గుర్తు ఉంచబడిన 'కౌట్' ను మేము జోడిస్తాము. ఇప్పుడు, ఇది “@” చిహ్నాన్ని త్రిభుజాకారంగా అందిస్తుంది.
కోడ్ 3:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
కోసం ( int i = 1 ; i < = 6 ; i++ ) {
కోసం ( int j = 1 ; జె < = నేను; j++ ) {
కోట్ << '@' ;
}
కోట్ << endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము అందించిన కోడ్‌లో ఉపయోగించిన “నెస్టెడ్ లూప్” కారణంగా మేము ఈ ఫలితాన్ని పొందుతాము. ఇక్కడ, “@” గుర్తు త్రిభుజాకార నమూనాలో కనిపించడాన్ని మనం చూడవచ్చు.
ఉదాహరణ 4:
మేము '@' చిహ్నాన్ని త్రిభుజం నమూనాలో చూపించడానికి 'నెస్టెడ్ ఫర్' లూప్‌ని ఉపయోగించాలనుకుంటున్నాము. దీన్ని చేయడానికి, మేము మొదటి 'కోసం' లూప్‌ను ఉంచుతాము. అప్పుడు, మేము '1' విలువతో 'int a' వేరియబుల్‌ని ప్రారంభించాము మరియు దాని స్థితిని 'a <= 8'కి సెట్ చేస్తాము. తరువాత, మేము ఈ సందర్భంలో “a” విలువను కూడా పెంచుతాము. అప్పుడు, మనకు మరొక “for” ఉంది, ఇక్కడ మనం “b <= a”ని సూచించే మరొక షరతుతో “1” విలువతో “int” గా “b” వేరియబుల్‌ని ప్రారంభించాము. 'a' విలువ కూడా అలాగే పెరిగింది. మనం '*' చిహ్నాన్ని ఉంచే చోట ఇప్పుడు 'కౌట్' జోడించబడింది. ఇది ఇప్పుడు కన్సోల్ త్రిభుజ నమూనాలో “*” గుర్తును ప్రదర్శించేలా చేస్తుంది.
కోడ్ 4:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
కోసం ( int a = 1 ; a < = 8 ; a++ ) {
కోసం ( int b = 1 ; బి < = a; b++ ) {
కోట్ << '* ' ;
}
కోట్ << endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
పైన పేర్కొన్న కోడ్‌లో “నెస్టెడ్ లూప్”ని ఉపయోగించడం ద్వారా మేము ఈ ఫలితాన్ని పొందాము. ఇక్కడ, “@” గుర్తు త్రిభుజంలో అమర్చబడిందని మనం గమనించవచ్చు.
ఉదాహరణ 5:
ఇప్పుడు, మేము ప్రధాన సంఖ్యను మాత్రమే రెండర్ చేయాలనుకుంటున్నాము. కాబట్టి, మేము “x” మరియు “y” వేరియబుల్స్‌ని “int” వేరియబుల్స్‌గా ప్రకటిస్తాము. అప్పుడు, మేము రెండు 'ఫర్' లూప్‌లను ఉంచుతాము, ఒకదాని తర్వాత ఒకటి, 'నెస్టెడ్ ఫర్' లూప్ అని చెప్పబడుతుంది. మొదటి లూప్ “x” వేరియబుల్‌ను “2”తో ప్రారంభించిన తర్వాత “x <= 50” అనే స్థితిని కలిగి ఉంటుంది. మేము ఈ లూప్‌లో “x” విలువపై ఇంక్రిమెంటేషన్ కూడా చేస్తాము.
అప్పుడు, మనకు మరొక లూప్ ఉంది, ఇక్కడ “y” వేరియబుల్‌కు “2” విలువను కేటాయించిన తర్వాత “y <= (x/y)” అని చెప్పే మరొక షరతును జోడిస్తాము. మేము ఈ లూప్‌లో “y” విలువను కూడా పెంచుతాము. దీని క్రింద, మేము '!(x%y)' పరిస్థితిని తనిఖీ చేసే 'if'ని ఉపయోగిస్తాము. కారకం ఇక్కడ కనుగొనబడకపోతే, మనం “బ్రేక్” స్టేట్‌మెంట్‌ను జోడించి, కింది వాటిలో జోడించే రెండవ “if” వైపు వెళ్లినప్పుడు అది ఆ విలువను ప్రింట్ చేయదు. ఇక్కడ, ఇది “y > (x/y)” అనే స్థితిని మళ్లీ తనిఖీ చేస్తుంది. ఇది నిజమైతే, అది ఆ విలువను ప్రింట్ చేస్తుంది మరియు “ఒక ప్రధాన సంఖ్య” అని కూడా ప్రింట్ చేస్తుంది.
కోడ్ 5:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
int x, y;
కోసం ( x = 2 ; x < = యాభై ; x++ ) {
కోసం ( y = 2 ; మరియు ( x / మరియు ) ) కోట్ << x << ' ఒక ప్రధాన సంఖ్య.' << endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇప్పుడు, మన కోడ్‌లో “నెస్టెడ్ ఫర్” లూప్‌ని వర్తింపజేసిన తర్వాత మనకు లభించే అన్ని ప్రధాన సంఖ్యలు ఇక్కడ రెండర్ చేయబడ్డాయి.
ముగింపు
ఈ గైడ్ అంతా C++లోని సమూహ లూప్‌ల గురించి మరియు మేము కోడ్ యొక్క విభాగం యొక్క పునరావృతం కావాలనుకున్నప్పుడు మేము 'నెస్టెడ్ లూప్‌లను' ఉపయోగించుకుంటామని వివరించాము. మేము ఈ భావనను క్షుణ్ణంగా అన్వేషించాము మరియు మా కోడ్‌లలో 'నెస్టెడ్ లూప్‌లను' ఎలా ఉపయోగించాలో నేర్చుకున్నాము. మేము వాటి వివరణలతో పాటుగా 'నెస్టెడ్ లూప్‌లను' ఉపయోగించిన అనేక ఉదాహరణలను ప్రదర్శించాము మరియు ఈ అన్ని కోడ్‌ల ఫలితాలను ఈ గైడ్‌లో ఇక్కడ అందించాము.