లూప్ C++ కోసం

Lup C Kosam

C++లో, లూప్ స్టేట్‌మెంట్‌లు నిర్దిష్ట కోడ్ లేదా స్టేట్‌మెంట్‌ను పునరావృతం చేస్తాయి. ఒకే ఫంక్షన్‌ను ఒకటి కంటే ఎక్కువసార్లు చేయడం ద్వారా కోడ్‌ను తగ్గించడానికి మరియు రిడెండెన్సీని తగ్గించడానికి అవి ఎక్కువగా ఉపయోగించబడతాయి. లూప్‌ల కోసం, అయితే లూప్‌లు మరియు డూ-వైల్ లూప్‌లు C++ ద్వారా మద్దతిచ్చే లూప్ రకాల్లో కొన్ని మాత్రమే. ప్రతిదానికి ప్రత్యేకమైన సింటాక్స్, ప్రయోజనాలు మరియు అప్లికేషన్ ఉన్నాయి. మేము కోడ్ బ్లాక్‌ను పదేపదే అమలు చేయాలనుకున్నప్పుడు, లూప్ అని పిలువబడే ప్రోగ్రామింగ్ నియంత్రణ నిర్మాణాన్ని ఉపయోగిస్తాము. సాధారణంగా, ఇది అమలవుతూనే ఉంటుంది మరియు ఒక నిర్దిష్ట ప్రమాణాన్ని పాటించినప్పుడు ఆగిపోతుంది. మీరు ఈ పోస్ట్‌లో C++ ఫర్ లూప్ అనే కీలకమైన ఆలోచనను కనుగొంటారు.

C++లో లూప్ అంటే ఏమిటి?

ఈ పునరావృత నియంత్రణ నిర్మాణం C++ కోడ్ యొక్క నిర్దిష్ట ప్రాంతంపై పదేపదే లూప్ చేయడానికి అనుమతిస్తుంది. పరీక్ష వ్యక్తీకరణ నిజమని చూపితే, లూప్ కోసం a అమలు చేయబడుతుంది. పరీక్ష వ్యక్తీకరణ తప్పు అయిన వెంటనే, లూప్ రన్ చేయడం ఆగిపోతుంది. ప్రతి పునరావృతానికి ముందు, పరిస్థితిని తనిఖీ చేయాలి. మూల్యాంకనం నిజమైన ఫలితాన్ని ఉత్పత్తి చేస్తే లూప్ యొక్క శరీరం అమలు చేయబడుతుంది.



లూప్ కోసం సింటాక్స్

క్రింద, మేము C++ భాషలో for loop యొక్క సింటాక్స్‌ని పేర్కొన్నాము.




'init వ్యక్తీకరణ' మొదటి పరామితి. మేము ఈ వ్యక్తీకరణలో నిర్దిష్ట సంఖ్యకు లూప్ కౌంటర్‌ని ప్రారంభించాలి. ఉదాహరణకు, int i=1.



‘కండిషన్’ అనేది రెండవ పరామితి. మేము ఇక్కడ పరిస్థితిని పరీక్షించాలి. ప్రమాణం నెరవేరినట్లయితే, ఫర్ లూప్ కొనసాగుతుంది; అది లేకపోతే, అది ముగుస్తుంది. తదుపరి ఉదాహరణలో, i <= 5 అయితే. ఇంక్రిమెంట్ అనేది మూడవ మరియు చివరి పరామితి. లూప్ బాడీ రన్ అయిన తర్వాత ఈ వ్యక్తీకరణ లూప్ వేరియబుల్‌ని నిర్దిష్ట సంఖ్యలో పెంచుతుంది/తగ్గిస్తుంది. ఉదాహరణకు: i++;.

ఇప్పుడు లూప్ గురించి చర్చించే కొన్ని ప్రోగ్రామింగ్ ఉదాహరణలను చూద్దాం.

ఉదాహరణ 1:

మా మొదటి ఉదాహరణలో, మేము మొదటి 15 సహజ పూర్ణాంకాలను ముద్రించడానికి for loopని ఉపయోగించాము. ఫర్ లూప్ ఎలా పనిచేస్తుందో చూపించడానికి, జోడించిన కోడ్‌ని చూడండి.



iostream హెడర్ ఫైల్ కోడ్‌లో చొప్పించిన తర్వాత ప్రధాన పద్ధతి ప్రారంభించబడుతుంది. ఒక సంఖ్య ప్రారంభించబడింది, అది 15 కంటే తక్కువ లేదా సమానంగా ఉందో లేదో చూడడానికి ఒక షరతు వ్రాయబడుతుంది. ఫర్ లూప్‌లో ప్రతి పునరావృతం తర్వాత సంఖ్య పెరుగుతుంది. కోడ్‌లో, ఇది (సంఖ్య=4; సంఖ్య=15; సంఖ్య++) అని వ్రాయబడింది.

షరతు “సంఖ్య <= 15” పరిశీలించబడింది. షరతు సంతృప్తి చెందితే లూప్ బాడీలో వ్రాసిన స్టేట్‌మెంట్‌లు అమలు చేయబడతాయి. ఒకవేళ షరతు తప్పు అని తేలితే, ప్రోగ్రామ్ లూప్ లోపల వ్రాసిన స్టేట్‌మెంట్‌లను అమలు చేస్తుంది. మరియు for loop యొక్క కోడ్ యొక్క బాడీని అమలు చేసిన తర్వాత, “number++” ఆదేశం అమలు చేయబడుతుంది. ఈ దృష్టాంతంలో, ప్రతిసారి for loop యొక్క బాడీ కోడ్ అమలు చేయబడినప్పుడు, 'సంఖ్య' విలువ 1 ద్వారా పెరుగుతుంది. ప్రతి లూప్ తర్వాత మీరు అమలు చేయాలనుకుంటున్న ఏదైనా వ్యక్తీకరణ ఇక్కడ ఉపయోగించవచ్చు.

పై ఉదాహరణలో, “సంఖ్య = 4” వేరియబుల్ “సంఖ్య”కి 4 విలువను ఇస్తుంది. తర్వాత, “సంఖ్య<=15” పరిస్థితి పరిశీలించబడుతుంది. 'సంఖ్య' విలువ 4 అయినందున for లూప్ బాడీలోని కోడ్ అమలు చేయబడుతుంది. ఫలితంగా, 'సంఖ్య' యొక్క ప్రస్తుత విలువ 4 ముద్రించబడుతుంది.

for loop కోడ్‌ల బాడీని అమలు చేసిన తర్వాత, దశ 'సంఖ్య++' అమలు చేయబడుతుంది, ఇది 'సంఖ్య' విలువను 1 ద్వారా పెంచుతుంది. కాబట్టి, 5 అనేది వేరియబుల్ 'సంఖ్య' యొక్క కొత్త విలువ.

“సంఖ్య<=15” షరతు మరోసారి తనిఖీ చేయబడింది మరియు నిజమని కనుగొనబడింది ఎందుకంటే “సంఖ్య” విలువ 5. లూప్ బాడీ కోడ్ మరోసారి అమలు చేయబడితే, 5 ముద్రించబడుతుంది. అప్పుడు, 'సంఖ్య' విలువ మరోసారి పెరిగింది.

“సంఖ్య” విలువ 15కి మార్చబడినప్పుడు, “సంఖ్య <= 15” అనే వ్యక్తీకరణ ఒప్పందానికి మూల్యాంకనం చేయబడుతుంది, 15ని ముద్రిస్తుంది. “సంఖ్య<=15” ఇప్పుడు తప్పుగా మారుతుంది మరియు సంఖ్య++ “సంఖ్య” విలువను పెంచినప్పుడు లూప్ ముగుస్తుంది. ” నుండి 16.

# చేర్చండి

int ప్రధాన ( )

{

ఉపయోగించి నేమ్‌స్పేస్ std ;
int సంఖ్య ;
కోసం ( సంఖ్య = 4 ; సంఖ్య <= పదిహేను ; సంఖ్య ++ )
{
కోట్ << సంఖ్య << endl ;
}
తిరిగి 0 ;
}

4 నుండి 15 వరకు ఉన్న సంఖ్యలు ఫర్ లూప్ ఉపయోగించి ముద్రించబడడాన్ని మీరు చూడగలిగే అవుట్‌పుట్ ఇక్కడ ఉంది.

ఉదాహరణ 2:

సానుకూల సంఖ్య యొక్క కారకాన్ని మేము నిర్ణయించే రెండవ ఉదాహరణ ఇది. మొదట, iostream హెడర్ ఫైల్ మా కోడ్‌లో చేర్చబడింది. ఈ ఫైల్ మమ్మల్ని కన్సోల్ నుండి చదవడానికి మరియు వ్రాయడానికి అనుమతిస్తుంది. తర్వాత, దాని తరగతులు మరియు ఫంక్షన్‌లను కాల్ చేయకుండా యాక్సెస్ చేయడానికి, మేము std నేమ్‌స్పేస్‌ని చేర్చాము. ప్రోగ్రామ్ యొక్క లాజిక్‌ని కలిగి ఉండే మెయిన్() పద్ధతిని కింది కోడ్ లైన్‌లో పిలుస్తారు. ప్రధాన() ఫంక్షన్ బాడీ అంటే {   దాని ప్రారంభాన్ని సూచిస్తుంది. ఇక్కడ, పూర్ణాంక వేరియబుల్స్ a, n మరియు వాస్తవం ప్రకటించబడ్డాయి. వాస్తవం వేరియబుల్‌కు 1 విలువ సెట్ చేయబడింది. కన్సోల్‌లో, మేము కొంత వచనాన్ని ముద్రించాము. “దయచేసి ఏదైనా సానుకూల సంఖ్యను టైప్ చేయండి:” అని టెక్స్ట్‌లో వ్రాయబడింది.

టెక్స్ట్‌లోని వేరియబుల్ సంఖ్య కోసం విలువను ఇన్‌పుట్ చేయమని వినియోగదారు అడగబడతారు. లూప్ కోసం A అప్పుడు నిర్మించబడింది. ప్రారంభ సమయంలో 'a' పేరుతో పూర్ణాంక వేరియబుల్ సృష్టించబడుతుంది మరియు దానికి 1 విలువ ఇవ్వబడుతుంది. షరతు ప్రకారం a యొక్క విలువ వేరియబుల్ 'n' విలువకు ఎక్కువగా లేదా సమానంగా ఉండకూడదు. ప్రతి పునరావృతం తర్వాత, ఇంక్రిమెంట్ 'a' విలువను 1 ద్వారా పెంచుతుంది. for-loop యొక్క శరీరం గుర్తు () ద్వారా పరిచయం చేయబడింది. కారకం విలువను లెక్కించడానికి కింది కోడ్‌లో వాస్తవం = వాస్తవం * a అనే సూత్రం ఉపయోగించబడింది. లూప్ అప్పుడు ముగింపుకు వస్తుంది.

వేరియబుల్స్ “n” మరియు “ఫాక్ట్” విలువలు కింది లైన్‌లో అదనపు టెక్స్ట్‌తో పాటు కన్సోల్‌లో ముద్రించబడతాయి. ప్రోగ్రామ్ విజయవంతంగా నడుస్తుంటే, ప్రధాన() ఫంక్షన్ విలువను అందిస్తుంది. చివరగా, ప్రధాన() ఫంక్షన్ యొక్క శరీరం యొక్క ముగింపును చూడవచ్చు. ఇక్కడ మొత్తం కోడ్ ఉంది:

# చేర్చండి

ఉపయోగించి నేమ్‌స్పేస్ std ;

int ప్రధాన ( )

{

int a, n, వాస్తవం = 1 ;
కోట్ <> n ;
కోసం ( a = 1 ; a <= n ; ++ a )
{
వాస్తవం * = a ;
}
కోట్ << 'ఇక్కడ కారకం' << n << ' = ' << వాస్తవం ;
తిరిగి 0 ;


}


మేము పైన పేర్కొన్న వాటిని అమలు చేసినప్పుడు, అది ముందుగా ఏదైనా సానుకూల సంఖ్యను అందించమని వినియోగదారుని అడుగుతుంది. అలా చేసినప్పుడు, ఆ సంఖ్య యొక్క కారకం అందించబడుతుంది.


ఇక్కడ, మీరు మా సందర్భంలో ఇచ్చిన సంఖ్య యొక్క కారకం 5 అని చూడవచ్చు.

ముగింపు

మేము ఈ కథనంలో లూప్ కోసం C++ గురించి వివరాలను అందించాము. ఒక నిర్దిష్ట షరతు నెరవేరే వరకు, స్టేట్‌మెంట్‌ల సేకరణ ఫర్ లూప్‌లో నిరంతరం అమలు చేయబడుతుంది. మీ సహాయం కోసం, మేము రెండు సమగ్ర ఉదాహరణలను కూడా అందించాము.