విషయము

• పోలిక చార్ట్
• లూప్ కోసం నిర్వచనం
• సింటాక్స్
• ప్రతి లూప్ మరియు దాని వాక్యనిర్మాణం
• ఉదాహరణ
• అయితే లూప్ యొక్క నిర్వచనం
• సింటాక్స్
• ఉదాహరణ
• గమనిక:
• ముగింపు:

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

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

ఉచ్చులు మరియు వాటి మధ్య కొన్ని ప్రధాన తేడాలు ఉన్నాయి, ఇవి పోలిక చార్ట్ సహాయంతో మరింత వివరించబడ్డాయి.

1. పోలిక చార్ట్
2. నిర్వచనం
3. కీ తేడాలు
4. ముగింపు

పోలిక చార్ట్

పోలిక కోసం ఆధారం	కోసం	అయితే
ప్రకటన	(ప్రారంభించడం; పరిస్థితి; మళ్ళా) { // బాడీ ఆఫ్ ఫర్ లూప్ }	అయితే (షరతు) { ప్రకటనలు; // బాడీ ఆఫ్ లూప్ }
ఫార్మాట్	ప్రారంభించడం, కండిషన్ చెకింగ్, మళ్ళా స్టేట్మెంట్ లూప్ ఎగువన వ్రాయబడతాయి.	లూప్ ఎగువన ప్రారంభించడం మరియు కండిషన్ చెకింగ్ మాత్రమే జరుగుతుంది.
వా డు	పునరావృతాల సంఖ్య మనకు ఇప్పటికే తెలిసినప్పుడు మాత్రమే ఫర్ లూప్ ఉపయోగించబడుతుంది.	పునరావృత సంఖ్య ఖచ్చితంగా తెలియనప్పుడు మాత్రమే లూప్ ఉపయోగించబడుతుంది.
కండిషన్	కండిషన్ లూప్ కోసం ఉంచకపోతే, లూప్ అనంతమైన సార్లు మళ్ళిస్తుంది.	కండిషన్ లూప్‌లో ఉంచకపోతే, ఇది సంకలన లోపాన్ని అందిస్తుంది.
మొదలుపెట్టటం	లూప్ కోసం ఒకసారి ప్రారంభించిన తర్వాత పునరావృతం కాదు.	కండిషన్ చెకింగ్ సమయంలో ప్రారంభించినట్లయితే లూప్ అయితే, లూప్ మళ్ళించే ప్రతిసారీ ప్రారంభించడం జరుగుతుంది.
పునరావృత ప్రకటన	ఫర్ లూప్ మళ్ళా స్టేట్మెంట్ పైభాగంలో వ్రాయబడింది, అందువల్ల, లూప్‌లోని అన్ని స్టేట్‌మెంట్‌లు అమలు అయిన తర్వాత మాత్రమే అమలు అవుతుంది.	లూప్‌లో ఉన్నప్పుడు, పునరావృత ప్రకటనను లూప్‌లో ఎక్కడైనా వ్రాయవచ్చు.

లూప్ కోసం నిర్వచనం

జావాలో, రెండు రూపాలు ఉన్నాయి కోసం ఉచ్చులు. మొదటి రూపం “సాంప్రదాయ” రూపం మరియు రెండవది “ప్రతి ఒక్కరికి” రూపం.

సింటాక్స్

లూప్ స్టేట్మెంట్ కోసం సాంప్రదాయక సాధారణ రూపం.

for (ప్రారంభించడం; కండిషన్; మళ్ళా) {// బాడీ ఆఫ్ ఫర్ లూప్}

• మొదలుపెట్టటం - లూప్ యొక్క లూప్ కంట్రోలింగ్ వేరియబుల్ యొక్క ప్రారంభించడం లూప్ యొక్క మొదటి పునరావృత సమయంలో ఒక్కసారి మాత్రమే అమలు చేయబడుతుంది. ఇక్కడ, లూప్ కంట్రోలింగ్ వేరియబుల్ ప్రారంభించబడింది, కొన్నిసార్లు ప్రోగ్రామ్‌లో మరెక్కడా లూప్ వేరియబుల్ ఉపయోగించబడకపోతే మరియు లూప్ యొక్క కంట్రోలింగ్ వేరియబుల్‌గా మాత్రమే ఉపయోగించబడితే, అది ‘ఫర్’ లూప్‌లో ప్రకటించబడుతుంది మరియు ప్రారంభించబడుతుంది.
• కండిషన్ - లూప్ పునరావృతమయ్యే ప్రతిసారీ ‘ఫర్’ లూప్ యొక్క పరిస్థితి అమలు అవుతుంది.
• పెరుగుదల మరియు పునరావృతం- మళ్ళా ప్రకటన అనేది లూప్ కంట్రోలింగ్ వేరియబుల్‌ను పెంచే లేదా తగ్గించే వ్యక్తీకరణ.

లూప్ ఎగ్జిక్యూట్ అయినప్పుడల్లా, దాని ప్రారంభ స్థితి మొదట అమలు అవుతుంది; అప్పుడు పరిస్థితి తనిఖీ చేయబడుతుంది. పరిస్థితి సంతృప్తి చెందితే, లూప్ యొక్క శరీరం అమలు చేయబడుతుంది, అప్పుడు పునరావృత ప్రకటన అమలు అవుతుంది. మరలా, లూప్ మరింత మళ్ళిస్తుందా లేదా ముగుస్తుందో లేదో తెలుసుకోవడానికి పరిస్థితి తనిఖీ చేయబడుతుంది.

జావాలో, ప్రారంభ ప్రకటన మరియు పునరుక్తి ప్రకటన ఒకటి కంటే ఎక్కువ స్టేట్‌మెంట్‌లను కలిగి ఉండవచ్చు. ప్రతి స్టేట్‌మెంట్‌ను కామాతో వేరుచేస్తారు, జావాలో, కామా వేరుచేసేది, అయితే C ++ లో, “కామా” అనేది ఏదైనా చెల్లుబాటు అయ్యే వ్యక్తీకరణలో ఉపయోగించగల ఆపరేటర్.

ప్రతి లూప్ మరియు దాని వాక్యనిర్మాణం

“ప్రతి ఒక్కరికీ” రూపం లూప్ కోసం మెరుగుపరచబడింది. ప్రతి లూప్ యొక్క సాధారణ రూపం క్రింది విధంగా ఉంటుంది.

(iter_variable: collection అని టైప్ చేయండి) స్టేట్మెంట్-బ్లాక్

ఇక్కడ, “రకం” మళ్ళా వేరియబుల్ రకాన్ని నిర్దేశిస్తుంది, తరువాత మళ్ళా వేరియబుల్. పునరావృత వేరియబుల్ సేకరణ వేరియబుల్ నుండి మూలకాన్ని అందుకుంటుంది. సేకరణ వేరియబుల్‌లో నిల్వ చేయబడిన మూలకాల రకానికి సమానంగా ఉండాలి. ఫర్-లూప్ యొక్క ప్రతి రూపం వరుస క్రమంలో విలువలను యాక్సెస్ చేయడం ప్రారంభం నుండి చివరి వరకు లూప్ యొక్క మళ్ళాను ఆటోమేట్ చేస్తుంది.

ఉదాహరణ

లూప్ కోసం వివిధ రకాల సేకరణలు ఉన్నాయి. దీన్ని సేకరణగా శ్రేణితో చర్చిద్దాం.

పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్) {int శ్రేణి = {10, 20, 30, 40, 50, 60}; పూర్ణాంకానికి జోడించు = 0; (int c: array) {System.out.ln ("c లో విలువ" + c); add = add + c; . System.out.ln ("శ్రేణి మూలకాల యొక్క సంకలనం" + జోడించు); 10} // అవుట్పుట్ విలువ సి 10 విలువలో సి 20 విలువలో సి 30 విలువలో సి 30 విలువలో సి 40 విలువలో సి 50 విలువలో సి 60 విలువ సి 60 విలువ మూలకాల యొక్క 2160

ఇక్కడ, ‘సి’ ఒక పునరుక్తి వేరియబుల్; ఇది విలువలను శ్రేణి నుండి, ఒక సమయంలో, అత్యల్ప సూచిక నుండి శ్రేణిలోని అత్యధిక సూచిక వరకు పొందుతుంది. ఇక్కడ, శ్రేణి యొక్క అన్ని అంశాలను పరిశీలించే వరకు లూప్ మళ్ళిస్తుంది. “బ్రేక్” ను ఉపయోగించడం ద్వారా లూప్‌ను ముగించడం సాధ్యమవుతుంది. అయినప్పటికీ, మళ్ళా వేరియబుల్‌లో మార్పు శ్రేణిని ప్రభావితం చేయదు, ఎందుకంటే ఇది చదవడానికి మాత్రమే వేరియబుల్ మాత్రమే.

అయితే లూప్ యొక్క నిర్వచనం

ది అయితే C ++ మరియు జావాలో లభించే అత్యంత ప్రాథమిక లూప్ లూప్. కాసేపు లూప్ యొక్క పని C ++ మరియు జావా రెండింటిలోనూ సమానంగా ఉంటుంది.

సింటాక్స్

కాసేపు లూప్ యొక్క ప్రకటన క్రింది విధంగా ఉంది

(షరతు) {ప్రకటనలు; // లూప్ బాడీ}

అయితే లూప్ మొదట్లో పరిస్థితిని తనిఖీ చేస్తుంది మరియు తరువాత లూప్ నిజమని తేలినంత వరకు స్టేట్మెంట్లను అమలు చేస్తుంది. అయితే లూప్‌లోని పరిస్థితి ఏదైనా బూలియన్ వ్యక్తీకరణ కావచ్చు. వ్యక్తీకరణ ఏదైనా సున్నా కాని విలువను తిరిగి ఇచ్చినప్పుడు, పరిస్థితి నిజం, మరియు వ్యక్తీకరణ సున్నా విలువను తిరిగి ఇస్తే, పరిస్థితి తప్పు అవుతుంది.

షరతు నిజమైతే, లూప్ స్వయంగా మళ్ళిస్తుంది, మరియు పరిస్థితి తప్పుగా మారితే, నియంత్రణ వెంటనే కోడ్ యొక్క తదుపరి పంక్తికి వెళుతుంది, వెంటనే లూప్ వస్తుంది. స్టేట్మెంట్స్ లేదా బాడీ లూప్ ఖాళీ స్టేట్మెంట్ లేదా ఒకే స్టేట్మెంట్ లేదా స్టేట్మెంట్స్ బ్లాక్ కావచ్చు.

ఉదాహరణ

కాసేపు లూప్ యొక్క పనిని చర్చిద్దాం. కోడ్ క్రింద ఉన్న ఉదాహరణలో 1 నుండి 10 వరకు ఉంటుంది.

// ఉదాహరణ జావాలో ఉంది. పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్) {int n = 0; (n <10) {n ++; System.out.ln ("n =" + n); output}} // అవుట్పుట్ n = 1 n = 2 n = 3 n = 4 n = 5 n = 6 n = 7 n = 8 n = 9 n = 10

ఇక్కడ, ‘n’ యొక్క ప్రారంభ విలువ 0, ఇది లూప్‌ను నిజం చేసేటప్పుడు పరిస్థితిని చేస్తుంది. నియంత్రణ అప్పుడు లూప్ యొక్క శరీరంలోకి ప్రవేశిస్తుంది మరియు కాసేపు లూప్ యొక్క శరీరంలోని మొదటి స్టేట్మెంట్ ప్రకారం ‘n’ విలువ పెరుగుతుంది. ‘N’ యొక్క విలువ ed, ఆపై నియంత్రణ కొంతకాలం లూప్‌లోకి తిరిగి వెళుతుంది, ఇప్పుడు ‘n’ యొక్క విలువ 1, ఇది మళ్లీ పరిస్థితిని సంతృప్తిపరుస్తుంది మరియు లూప్ యొక్క శరీరం మళ్లీ అమలు అవుతుంది. షరతు నిజం అయ్యే వరకు ఇది కొనసాగుతుంది, పరిస్థితి తప్పు అయిన వెంటనే, లూప్ ముగించబడుతుంది.

‘ఫర్’ లూప్ మాదిరిగా, ‘అయితే’ లూప్ కూడా లూప్ ఎగువన ఉన్న కంట్రోల్ వేరియబుల్‌ను ప్రారంభించగలదు, అనగా కండిషన్ చెకింగ్ సమయంలో.

// ఉదాహరణకు ((ch = getchar ())! = A) {System.out.ln ("ఇన్పుట్ వర్ణమాల" + ch); }

ఇక్కడ కంట్రోల్ వేరియబుల్ ‘ch’ ప్రారంభించబడింది మరియు లూప్ యొక్క పరిస్థితి లూప్ ఎగువన ధృవీకరించబడుతుంది.

గమనిక:

ఇది లూప్ లేదా కాసేపు లూప్ కావచ్చు, లూప్ యొక్క శరీరంలో ఒకే ఒక ప్రకటన ఉంటే, ఆ స్థితిలో వంకర కలుపులు అవసరం లేదు.

1. లో కోసం లూప్, ప్రారంభించడం, కండిషన్ చెకింగ్ మరియు మళ్ళా వేరియబుల్ యొక్క పెరుగుదల లేదా తగ్గుదల లూప్ యొక్క వాక్యనిర్మాణంలో మాత్రమే స్పష్టంగా జరుగుతుంది. వ్యతిరేకంగా, లో అయితే లూప్ మేము లూప్ యొక్క వాక్యనిర్మాణంలో మాత్రమే స్థితిని ప్రారంభించవచ్చు మరియు తనిఖీ చేయవచ్చు.
2. లూప్ యొక్క అమలులో సంభవించే పునరావృతాల సంఖ్య గురించి మనకు తెలిసినప్పుడు, అప్పుడు మేము ఉపయోగిస్తాము కోసం లూప్. మరోవైపు, లూప్‌లో సంభవించే పునరావృత సంఖ్య గురించి మనకు తెలియకపోతే, మేము ఉపయోగిస్తాము అయితే లూప్.
3. మీరు కండిషన్ స్టేట్మెంట్ పెట్టడంలో విఫలమైతే కోసం లూప్, ఇది లూప్ యొక్క అనంతమైన పునరావృతానికి దారి తీస్తుంది. దీనికి విరుద్ధంగా, మీరు కండిషన్ స్టేట్మెంట్ ఇవ్వడంలో విఫలమైతే అయితే లూప్ అది సంకలన లోపానికి దారి తీస్తుంది.
4. యొక్క వాక్యనిర్మాణంలో ప్రారంభ ప్రకటన కోసం లూప్ ప్రారంభంలో లూప్ ఒక్కసారి మాత్రమే అమలు చేస్తుంది. దీనికి విరుద్ధంగా అయితే లూప్ దాని వాక్యనిర్మాణంలో ప్రారంభ ప్రకటనను తీసుకువెళుతుంది, ఆపై లూప్ పునరావృతమయ్యే ప్రతిసారీ లూప్‌లోని ప్రారంభ ప్రకటన అమలు అవుతుంది.
5. లో పునరావృత ప్రకటన కోసం లూప్ ఎగ్జిక్యూట్ కోసం శరీరం తర్వాత లూప్ అమలు అవుతుంది. దీనికి విరుద్ధంగా, పునరుక్తి ప్రకటన శరీరంలో ఎక్కడైనా వ్రాయబడుతుంది అయితే లూప్ కాబట్టి, లూప్ యొక్క శరీరంలో పునరుక్తి ప్రకటన అమలు చేసిన తర్వాత అమలు చేసే కొన్ని స్టేట్‌మెంట్‌లు ఉండవచ్చు.

ముగింపు:

ఫర్ లూప్ మరియు లూప్ రెండూ పునరావృత ప్రకటన, కానీ రెండూ వాటి ప్రత్యేక లక్షణాన్ని కలిగి ఉంటాయి. ఫర్ లూప్ దాని అన్ని డిక్లరేషన్ (ప్రారంభించడం, కండిషన్, మళ్ళా) లూప్ యొక్క శరీరం పైభాగంలో ఉంటుంది. దీనికి విరుద్ధంగా, లూప్ యొక్క ప్రారంభ మరియు స్థితి మాత్రమే లూప్ యొక్క శరీరం పైభాగంలో ఉంటుంది మరియు లూప్ యొక్క శరీరంలో ఎక్కడైనా పునరావృతం వ్రాయబడుతుంది.