విషయ సూచిక:
- C++లో లూప్ అయితే ఏమిటి
- అయితే లూప్ యొక్క సింటాక్స్
- C++లో లూప్ అయితే ఎలా ఉపయోగించాలి
- C++ నెస్టెడ్ అయితే లూప్
- C++ ఇన్ఫినిట్ అయితే లూప్
- C++లో అయితే లూప్‌లతో సరి మరియు బేసి సంఖ్యలను ముద్రించడం
- ముగింపు
C++లో లూప్ అయితే ఏమిటి
కాలే లూప్ అనేది నియంత్రణ నిర్మాణం, ఇది కండిషన్ ఒప్పు అని మూల్యాంకనం చేసినంత కాలం అమలులో కొనసాగుతుంది మరియు కండిషన్ తప్పుగా మారిన తర్వాత అది ఆగిపోతుంది. ఒక నిర్దిష్ట షరతు నెరవేరే వరకు మీరు ఒక నిర్దిష్ట పనిని పునరావృతం చేయాలనుకునే సందర్భాల్లో ఇది ఉపయోగకరంగా ఉంటుంది.
ఉదాహరణకి , మీరు 1 నుండి 10 వరకు సంఖ్యలను ప్రింట్ చేయడానికి కాసేపు లూప్‌ని ఉపయోగించవచ్చు లేదా ఇచ్చిన సంఖ్య యొక్క కారకాన్ని లెక్కించవచ్చు.
అయితే లూప్ యొక్క సింటాక్స్
C++లో కాసేపు లూప్ యొక్క ప్రాథమిక వాక్యనిర్మాణం క్రింది విధంగా ఉంది:
అయితే ( పరిస్థితి ) {
// కోడ్ అమలు చేయాలి
}
షరతు నిజం అయినంత వరకు కర్లీ బ్రేస్‌లలోని కోడ్ పదే పదే అమలు చేయబడుతుంది. లూప్ నడుస్తున్న ప్రతిసారీ పరిస్థితి తనిఖీ చేయబడుతుంది.
C++లో లూప్ అయితే ఎలా ఉపయోగించాలి
లూప్‌లు ప్రారంభ స్థానం నుండి ముగింపు బిందువు వరకు లెక్కించబడుతున్నాయి అనేదానికి అత్యంత సాధారణ ఉదాహరణలలో ఒకటి. ఉదాహరణకి, కింది కోడ్ 1 నుండి 10 వరకు లెక్కించబడుతుంది:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int i = 1 ; // కౌంటర్ వేరియబుల్‌ని 1కి ప్రారంభించండి
కౌంటర్ వేరియబుల్ 10 కంటే తక్కువగా లేదా సమానంగా ఉన్నప్పుడు // లూప్
అయితే ( i <= 10 ) {
కోట్ << i << endl ; // కౌంటర్ వేరియబుల్ యొక్క ప్రస్తుత విలువను అవుట్పుట్ చేయండి
i ++; // కౌంటర్ వేరియబుల్‌ని పెంచండి
}
తిరిగి 0 ;
}
ఈ కోడ్ C++లో కాసేపు లూప్‌ను ఎలా ఉపయోగించాలో చూపుతుంది. ప్రోగ్రామ్ కౌంటర్ వేరియబుల్‌ని ప్రారంభిస్తుంది i 1 వరకు ఆపై కొంత సమయం లూప్‌ని అమలు చేస్తుంది, అది వరకు అమలులో కొనసాగుతుంది i 10 కంటే ఎక్కువ అవుతుంది.
అయితే లూప్ లోపల, కౌంటర్ వేరియబుల్ యొక్క ప్రస్తుత విలువను ఉపయోగించి కన్సోల్‌కు ముద్రించబడుతుంది కోట్ ప్రకటన, ఉపయోగించి లైన్ బ్రేక్ తర్వాత endl . కౌంటర్ వేరియబుల్ అప్పుడు 1 ద్వారా పెంచబడుతుంది i++ ప్రకటన.
కౌంటర్ వేరియబుల్ వరకు లూప్ అమలు చేయడం కొనసాగుతుంది i 11 విలువను చేరుకుంటుంది, ఆ సమయంలో అయితే లూప్ నిష్క్రమించబడుతుంది మరియు ప్రోగ్రామ్ రిటర్న్ విలువ 0తో ముగుస్తుంది.
C++ నెస్టెడ్ అయితే లూప్
అయితే లూప్‌లు కూడా కావచ్చు గూడు కట్టిన , దీనర్థం మీరు మరొక సమయంలో లూప్‌లో కొంత సమయం లూప్‌ని కలిగి ఉండవచ్చు. ఒక నిర్దిష్ట షరతు నెరవేరే వరకు మీరు ఒక పనిని పదేపదే నిర్వహించాల్సిన సందర్భాల్లో ఇది ఉపయోగపడుతుంది మరియు ఆ పనిలో, వేరొక షరతు నెరవేరే వరకు మీరు మరొక పనిని పదేపదే చేయవలసి ఉంటుంది.
నెస్టెడ్ అయితే లూప్‌లో, ఔటర్ లూప్ ఒకసారి ఎగ్జిక్యూట్ చేయబడుతుంది, ఆపై ఔటర్ లూప్ నడుస్తున్న ప్రతిసారీ ఇన్నర్ లూప్ ఎగ్జిక్యూట్ అవుతుంది. బాహ్య లూప్ యొక్క ప్రతి పునరావృతం కోసం లోపలి లూప్ పూర్తిగా ఒకసారి అమలు చేయబడుతుంది.
ఉదాహరణ
C++లో Nested while లూప్‌ని ఉపయోగించే ఉదాహరణ కోడ్ క్రింది విధంగా ఉంది:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int i = 1 ; // కౌంటర్ వేరియబుల్‌ని 1కి ప్రారంభించండి
// లూప్ అయితే కౌంటర్ వేరియబుల్ 3 కంటే తక్కువ లేదా సమానంగా ఉంటుంది
అయితే ( i <= 3 ) {
int జె = 1 ; // ఇన్నర్ కౌంటర్ వేరియబుల్‌ని 1కి ప్రారంభించండి
// లూప్ అయితే ఇన్నర్ కౌంటర్ వేరియబుల్ 3 కంటే తక్కువ లేదా సమానంగా ఉంటుంది
అయితే ( జె <= 3 ) {
కోట్ << i << '' << జె << ' \n ' ; // కౌంటర్ వేరియబుల్స్ యొక్క ప్రస్తుత విలువలను అవుట్పుట్ చేయండి
జె ++; // ఇంక్రిమెంట్ ఇన్నర్ కౌంటర్ వేరియబుల్
}
i ++; // ఇంక్రిమెంట్ ఔటర్ కౌంటర్ వేరియబుల్
}
తిరిగి 0 ;
}
ఈ కోడ్‌లో, ఔటర్ లూప్ ఉన్నంత వరకు నడుస్తుంది i విలువ ఉన్నప్పుడు 3కి సమానం అవుతుంది i 3 కంటే ఎక్కువ అవుతుంది లూప్ ఆగిపోతుంది. ప్రతి బాహ్య లూప్ పునరావృతంతో, అంతర్గత కౌంటర్ వేరియబుల్ జె 1కి ప్రారంభించబడింది మరియు లోపలి అయితే లూప్‌ని అమలు చేస్తుంది. యొక్క విలువ వరకు ఈ అంతర్గత లూప్ అమలవుతుంది జె కంటే ఎక్కువ అవుతుంది 3 .
లోపలి లూప్ లోపల, మేము విలువలను అవుట్పుట్ చేస్తాము i మరియు జె . ఆ తరువాత, మేము పెంచాము జె . అంతర్గత లూప్ మూడు సార్లు అమలు చేయబడే వరకు ఇది కొనసాగుతుంది. బాహ్య లూప్ పెరిగిన ప్రతిసారీ, అంతర్గత లూప్ కూడా మళ్లీ అమలు చేయబడుతుంది.
బాహ్య లూప్ మూడు సార్లు అమలు చేయబడి మరియు రెండు లూప్‌లు పూర్తయ్యే వరకు ఈ ప్రక్రియ పునరావృతమవుతుంది. ఈ కోడ్ యొక్క అవుట్పుట్ దిగువ చిత్రంలో చూపిన విధంగా 1 1 నుండి 3 3 వరకు ఉండే విలువల పట్టిక.
C++ ఇన్ఫినిట్ అయితే లూప్
C++లో అనంతం అయితే లూప్‌లు కూడా సాధ్యమే. నిర్వచించబడిన ఏ షరతు కూడా తప్పు కానందున అనంతమైన సమయంలో లూప్ నిరంతరంగా నడుస్తుంది. ఒక్కటే నిజమైన పరిస్థితి , ఇది while లూప్‌ను అనంతమైన సార్లు నిరంతరంగా అమలు చేయడానికి అనుమతిస్తుంది.
ఉదాహరణకి , క్రింద ఇవ్వబడిన లూప్ ఎప్పటికీ అమలు చేయబడుతుంది మరియు ఈ లూప్‌ను ఆపడానికి మనం ఈ లూప్ చివరిలో బ్రేక్ స్టేట్‌మెంట్‌ను నిర్వచించాలి.
అయితే ( నిజం ) {// కోడ్ అమలు చేయాలి
}
ఎంబెడెడ్ సిస్టమ్‌లలో లేదా వినియోగదారు ఇన్‌పుట్ కోసం వేచి ఉన్నప్పుడు వంటి కొన్ని సందర్భాల్లో అనంతమైన లూప్ ఉపయోగపడుతుంది.
ఉదాహరణ
C++ కోడ్‌లో అనంతమైన సమయంలో లూప్‌ను అమలు చేసే ఉదాహరణ C++ ప్రోగ్రామ్ క్రింద ఉంది:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int లెక్కించండి = 0 ;
అయితే ( నిజం ) {
కోట్ << 'ఇన్ఫినిటివ్ వైల్ లూప్ \n ' ;
లెక్కించండి ++;
ఉంటే ( లెక్కించండి >= 10 ) {
బ్రేక్ ;
}
}
తిరిగి 0 ;
}
ఇచ్చిన కోడ్ అనంతమైన లూప్‌ను సృష్టిస్తుంది, అది కన్సోల్‌కు “ఇన్ఫినిటివ్ వైల్ లూప్” స్ట్రింగ్‌ను నిరంతరం అవుట్పుట్ చేస్తుంది. ఎందుకంటే అయితే లూప్ యొక్క స్థితి ఒప్పుకు సెట్ చేయబడింది, ఇది ఎల్లప్పుడూ నిజమైన లూప్ ముగియదు.
అనంతమైన లూప్‌ను ఆపడానికి, నిర్దిష్ట షరతు నెరవేరినప్పుడు లూప్ నుండి నిష్క్రమించడానికి బ్రేక్ స్టేట్‌మెంట్‌ని ఉపయోగించవచ్చు. పై ప్రోగ్రామ్‌లో, మేము గరిష్ట పునరావృతాల సంఖ్యను 10కి సెట్ చేసాము, ఇది ద్వారా నియంత్రించబడుతుంది లెక్కించండి వేరియబుల్ మరియు బ్రేక్ స్టేట్‌మెంట్.
ఎగువ కోడ్ అనంతమైన సార్లు అమలు చేయబడుతుంది కానీ విరామం స్టేట్‌మెంట్‌ని ఉపయోగించడం 10 పునరావృతాల తర్వాత ఆపివేయబడుతుంది.
అయితే లూప్‌తో సరి మరియు బేసి సంఖ్యలను ముద్రించడం
అయితే లూప్‌లు సరి మరియు బేసి సంఖ్యలను ముద్రిస్తున్నాయనడానికి మరొక ఉదాహరణ. ఉదాహరణకి , కింది ఇవ్వబడిన కోడ్ 2 నుండి 10 వరకు సరి సంఖ్యలను అవుట్పుట్ చేయడానికి C++లో కొంత లూప్‌ని ఉపయోగిస్తుంది.
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int i = 2 ; // కౌంటర్ వేరియబుల్‌ని 2కి ప్రారంభించండి
// లూప్ అయితే కౌంటర్ వేరియబుల్ 10 కంటే తక్కువ లేదా సమానంగా ఉంటుంది
అయితే ( i <= 10 ) {
కోట్ << i << endl ; // కౌంటర్ వేరియబుల్ యొక్క ప్రస్తుత విలువను అవుట్పుట్ చేయండి
i += 2 ; // కౌంటర్ వేరియబుల్‌ను 2 ద్వారా పెంచండి
}
తిరిగి 0 ;
}
ఈ C++ కోడ్ కౌంటర్ వేరియబుల్‌ని ప్రారంభిస్తుంది i 2కి మరియు విలువను పదేపదే అవుట్పుట్ చేయడానికి కాసేపు లూప్‌ని ఉపయోగిస్తుంది i ఇది 10 కంటే తక్కువ లేదా సమానంగా ఉన్నంత వరకు. లూప్ యొక్క ప్రతి పునరావృతంలో, అది పెరుగుతుంది i 2 ద్వారా. లూప్ రన్ అయిన ప్రతిసారీ అవుట్పుట్ టెర్మినల్‌లో ముద్రించబడుతుంది. లూప్ పూర్తయిన తర్వాత, ప్రోగ్రామ్ విజయవంతమైన అమలును సూచించడానికి 0ని అందిస్తుంది.
అదేవిధంగా, మేము కూడా ప్రింట్ చేయవచ్చు బేసి 1 నుండి 9 వరకు సంఖ్యలు:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int i = 1 ; // కౌంటర్ వేరియబుల్‌ని 1కి ప్రారంభించండి
// లూప్ అయితే కౌంటర్ వేరియబుల్ 9 కంటే తక్కువ లేదా సమానంగా ఉంటుంది
అయితే ( i <= 9 ) {
కోట్ << i << endl ; // కౌంటర్ వేరియబుల్ యొక్క ప్రస్తుత విలువను అవుట్పుట్ చేయండి
i += 2 ; // కౌంటర్ వేరియబుల్‌ను 2 ద్వారా పెంచండి
}
తిరిగి 0 ;
}
ఈ కోడ్‌లో, కౌంటర్ వేరియబుల్ వరకు లూప్ కండిషన్ రన్ అవుతుంది i 9 కంటే తక్కువ లేదా సమానం కోట్ లూప్ లోపల స్టేట్‌మెంట్ ప్రస్తుత విలువను అవుట్పుట్ చేస్తుంది i , ఆపై ది i వేరియబుల్ ఉపయోగించి 2 ద్వారా పెంచబడుతుంది i += 2 ప్రకటన. లూప్ ద్వారా బేసి సంఖ్యలు మాత్రమే ముద్రించబడతాయని ఇది నిర్ధారిస్తుంది.
ప్రోగ్రామ్ ముగింపులో, మెయిన్() ఫంక్షన్ పూర్తయిందని సూచించడానికి రిటర్న్ స్టేట్‌మెంట్ ఉపయోగించబడుతుంది.
ముగింపు
ఎ వేల్ లూప్ అనేది ఒక నియంత్రణ నిర్మాణం, ఇది నిర్వచించిన షరతు నిజం అయినంత వరకు ప్రోగ్రామ్‌ను అమలు చేస్తుంది. ఇక్కడ మేము ప్రాథమిక సింటాక్స్ మరియు C++లో అయితే లూప్‌లను ఉపయోగించే ఉదాహరణలను కవర్ చేసాము. మేము ఒక సమయంలో లూప్‌ను సమూహ రూపంలో ఎలా ఉపయోగించాలో మరియు అనంతమైన సార్లు లూప్ చేసేటప్పుడు ఎలా రన్ చేయవచ్చో కూడా వివరిస్తాము. C++ అయితే లూప్ గురించి మరిన్ని వివరాల కోసం, కథనాన్ని చదవండి.