సి లో ఫర్ లూప్ పై ఈ వ్యాసంలో, ఫర్ లూప్స్ గురించి ప్రతిదీ అన్వేషిస్తాము దీన్ని అమలు చేయడానికి వివిధ మార్గాలకు. ఈ వ్యాసంలో క్రింది గమనికలు కవర్ చేయబడతాయి,
- సి లో లూప్ కోసం
- సి లో ఉచ్చులు
- లూప్ సింటాక్స్ కోసం
- సి లో లూప్ యొక్క వివిధ రూపాలు
- సి లో లూప్ కోసం గూడు
- జంప్ అవుట్ ఆఫ్ లూప్స్
కాబట్టి అప్పుడు ప్రారంభిద్దాం,
సి లో లూప్ కోసం
సంక్లిష్ట సమస్యలను సులభతరం చేస్తున్నందున అన్ని ప్రోగ్రామింగ్ భాషలలో లూప్ ప్రాథమిక భావనలలో ఒకటి. సరళమైన మాటలలో, ఇచ్చిన షరతు తప్పుగా వచ్చే వరకు లూప్ ఒకే కోడ్ యొక్క సమితిని అనేకసార్లు పునరావృతం చేస్తుంది. కాబట్టి, ఒకే కోడ్‌ను మళ్లీ మళ్లీ వ్రాయడానికి బదులుగా, ఒకే కోడ్‌ను అనేకసార్లు అమలు చేయడానికి లూప్‌ను ఉపయోగించవచ్చు.
ఉదాహరణకు, 1 నుండి 100 వరకు సహజ సంఖ్యలను ముద్రించడానికి, మీరు 100 ప్రింట్ స్టేట్‌మెంట్‌లను వ్రాయవచ్చు లేదా మీరు 100 పునరావృతాల కోసం లూప్‌ను అమలు చేయవచ్చు మరియు సహజ సంఖ్యలను ముద్రించవచ్చు. సహజంగానే రెండవ ఎంపిక సులభం & మరింత సాధ్యమే.
ఫర్ ఫర్ లూప్ ఇన్ సి వ్యాసంతో దీనితో కదులుతోంది,
సి లో ఉచ్చులు
లూప్ రెండు భాగాలను కలిగి ఉంటుంది:
- బాడీ ఆఫ్ లూప్: నిరంతరం అమలు చేయాల్సిన ప్రకటనల సమితిని కలిగి ఉంటుంది
- షరతులతో కూడిన ప్రకటన : ఒక షరతు. ఇది నిజమైతే, తదుపరి పునరావృతం అమలు అవుతుంది లేకపోతే అమలు ప్రవాహం లూప్ నుండి నిష్క్రమిస్తుంది.
సి లో లూప్ రకాలు
సి లో రెండు రకాల ఉచ్చులు ఉన్నాయి, అంటే ఎంట్రీ-కంట్రోల్డ్ లూప్స్ & ఎగ్జిట్ కంట్రోల్డ్ లూప్స్.
- ఎంట్రీ-నియంత్రిత ఉచ్చులు: ఎంట్రీ కంట్రోల్డ్ లూప్స్ అంటే లూప్ యొక్క శరీరాన్ని అమలు చేయడానికి ముందు పరీక్ష స్థితిని పరీక్షించే ఉచ్చులు. కోసం & లూప్ ఎంట్రీ-నియంత్రిత ఉచ్చులు.
- నియంత్రిత ఉచ్చుల నుండి నిష్క్రమించండి: నిష్క్రమణ నియంత్రిత ఉచ్చులు లూప్ యొక్క శరీరాన్ని అమలు చేసిన తర్వాత పరీక్ష స్థితిని పరీక్షించే ఉచ్చులు. do-while లూప్ నిష్క్రమణ-నియంత్రిత లూప్.
ఫర్ ఫర్ లూప్ ఇన్ సి వ్యాసంతో దీనితో కదులుతోంది,
లూప్ సింటాక్స్ కోసం
ఫర్ లూప్ అనేది లూపింగ్ స్ట్రక్చర్, ఇది ఇచ్చిన షరతు తప్పుగా వచ్చే వరకు కోడ్ యొక్క క్రమాన్ని అమలు చేయడానికి ఉపయోగించబడుతుంది. పునరావృతాల సంఖ్య ముందుగానే తెలిసినప్పుడు లూప్ కోసం ఉపయోగించడానికి ఉత్తమమైన పరిస్థితి.
సింటాక్స్:
(ప్రారంభ స్థితి పరీక్ష పెరుగుదల లేదా తగ్గింపు) {// కోడ్ యొక్క బ్లాక్ బ్లాక్ పదేపదే అమలు చేయబడుతుంది}ఫర్ లూప్ యొక్క ఫ్లో రేఖాచిత్రం
దశ 1: అమలు ప్రవాహంలో, మొదట కౌంటర్ వేరియబుల్ ప్రారంభించబడుతుంది.
దశ 2: పరీక్ష పరిస్థితి ధృవీకరించబడింది, ఇక్కడ ఇచ్చిన పరిస్థితి కోసం కౌంటర్ వేరియబుల్ పరీక్షించబడుతుంది. పరిస్థితి నిజమైతే, ఫంక్షన్ బాడీ లోపల ఉన్న కోడ్ యొక్క బ్లాక్ అమలు అవుతుంది, లేకపోతే ఫర్ లూప్ ఆగిపోతుంది మరియు నియంత్రణ లూప్ నుండి వస్తుంది.
దశ 3: ఫంక్షన్ బాడీని విజయవంతంగా అమలు చేస్తే, ఆపరేషన్ ఆధారంగా కౌంటర్ వేరియబుల్ పెరుగుతుంది లేదా తగ్గుతుంది.
ఉదాహరణ
(కౌంటర్ = 1 కౌంటర్ కోసం int ప్రధాన () {int కౌంటర్‌ను చేర్చండి<=10 counter++) { printf('%dn', counter) } return 0 }అవుట్పుట్:
ఫర్ ఫర్ లూప్ ఇన్ సి వ్యాసంతో దీనితో కదులుతోంది,
సి లో లూప్ యొక్క వివిధ రూపాలు
కౌంటర్ ++ & కౌంటర్ + 1 ఒకే అవుట్‌పుట్‌ను ఇస్తుంది.
ఉదాహరణ:
(కౌంటర్ = 1 కౌంటర్ కోసం int ప్రధాన () {int కౌంటర్‌ను చేర్చండి<=10 counter=counter+1) { printf('%dn', counter) } return 0 }అవుట్పుట్:
మీరు కౌంటర్ వేరియబుల్ యొక్క ప్రారంభాన్ని దాటవేయవచ్చు మరియు దానిని లూప్ ముందు ప్రకటించవచ్చు.
ఉదాహరణ:
(కౌంటర్ కోసం int main () {int counter = 1 ను చేర్చండి<=10 counter=counter+1) { printf('%dn', counter) } return 0 }అవుట్పుట్:
మీరు కౌంటర్ వేరియబుల్ యొక్క ప్రారంభాన్ని దాటవేయవచ్చు, కాని పరీక్ష స్థితికి ముందు సెమికోలన్ ఉండాలి, లేకుంటే అది సంకలన లోపాన్ని విసిరివేస్తుంది.
మీరు కౌంటర్ యొక్క పెరుగుదల లేదా తగ్గుదలని కూడా దాటవేయవచ్చు. కానీ ఈ దృష్టాంతంలో కౌంటర్ ఫర్-లూప్ బాడీ లోపల పెంచాలి.
జావాలో ఓవర్లోడింగ్ vs ఓవర్రైడింగ్
ఉదాహరణ:
(కౌంటర్ = 1 కౌంటర్ కోసం int ప్రధాన () {int కౌంటర్‌ను చేర్చండి<=10) { printf('%dn', counter) counter=counter+1 } return 0 }ఫర్ ఫర్ లూప్ ఇన్ సి వ్యాసంతో దీనితో కదులుతోంది,
మీరు ఫర్ లూప్‌లో పరిస్థితిని దాటవేయవచ్చు, దీని ఫలితంగా అనంతమైన లూప్ వస్తుంది.
ఉదాహరణ:
# కౌంటర్ (కౌంటర్ = 1 కౌంటర్ ++) {printf ('% dn', కౌంటర్)} తిరిగి 0} కోసం int ప్రధాన () {int కౌంటర్‌ను చేర్చండిఅవుట్పుట్:
ఇన్ఫింట్ లూప్
మేము లూప్ కోసం ఒకటి కంటే ఎక్కువ వేరియబుల్‌లను ప్రారంభించవచ్చు.
ఉదాహరణ:
# (x = 1, y = 2, z = 3 x కోసం int main () {int x, y, z చేర్చండి<5 x++, y++, z++) { printf('x %dn', x) printf('y %dn', y) printf('z %dn', z) } return 0 }అవుట్పుట్:
ఫర్ ఫర్ లూప్ ఇన్ సి వ్యాసంతో దీనితో కదులుతోంది,
సి లో లూప్ కోసం గూడు
సి లో లూప్ కోసం మీరు ఒకదానిని మరొకటి లోపల ఉంచవచ్చు. దీనిని లూప్ కోసం నెస్టెడ్ అంటారు.
ఉదాహరణ:
# చేర్చు<= rows i++ ) { for ( k = 1 k < blank k++ ) printf(' ') blank-- for ( k = 1 k <= 2*i - 1 k++ ) printf('*') printf('n') } return 0 }ఉదాహరణ:
ఫర్ ఫర్ లూప్ ఇన్ సి వ్యాసంతో దీనితో కదులుతోంది,
జంప్ అవుట్ ఆఫ్ లూప్స్
వివిధ సందర్భాల్లో, మీరు లూప్ నుండి నిష్క్రమించాలి లేదా నిర్దిష్ట షరతు నెరవేరినప్పుడు లూప్ యొక్క మళ్ళాను దాటవేయాలి. కాబట్టి, ఆ దృశ్యాలలో లూప్ నుండి దూకడం అంటారు. మీరు అదే సాధించడానికి రెండు మార్గాలు ఉన్నాయి.
బ్రేక్ స్టేట్మెంట్
లూప్ లోపల బ్రేక్ స్టేట్మెంట్ ఎదురైనప్పుడు, లూప్ వెంటనే నిష్క్రమిస్తుంది మరియు ప్రోగ్రామ్ లూప్ తరువాత వెంటనే స్టేట్మెంట్ తో కొనసాగుతుంది.
సమూహ లూప్ విషయంలో, లోపలి లూప్‌లో బ్రేక్ స్టేట్మెంట్ ఎదురైతే లోపలి లూప్ నిష్క్రమిస్తుంది.
ఉదాహరణ:
(కౌంటర్ = 1 కౌంటర్ కోసం int ప్రధాన () {int కౌంటర్‌ను చేర్చండి<=10 counter++) { if(counter==5) { break } printf('%dn', counter) } return 0 }అవుట్పుట్:
ప్రకటన కొనసాగించండి
కొనసాగించు స్టేట్మెంట్ నియంత్రణను నేరుగా పరీక్ష-స్థితికి పంపుతుంది, ఆపై లూప్ ప్రక్రియను కొనసాగించండి.
కొనసాగింపు కీవర్డ్‌ని ఎదుర్కొన్నప్పుడు, అమలు ప్రవాహం లూప్ యొక్క ప్రస్తుత పునరుక్తిని వదిలివేస్తుంది మరియు తదుపరి పునరావృతంతో ప్రారంభమవుతుంది.
ఉదాహరణ:
(కౌంటర్ = 1 కౌంటర్ కోసం int ప్రధాన () {int కౌంటర్‌ను చేర్చండి<=10 counter++) { if(counter%2==1) { continue } printf('%dn', counter) } return 0 }అవుట్పుట్:
దీనితో మనం ‘ఫర్ లూప్ ఇన్ సి’ లో ఈ బ్లాగ్ చివరకి వచ్చాము. మీరు ఈ సమాచార మరియు సహాయకారిని కనుగొన్నారని నేను నమ్ముతున్నాను, ఇలాంటి అంశాలపై మరిన్ని ట్యుటోరియల్స్ కోసం వేచి ఉండండి.మీరు మా శిక్షణా కార్యక్రమాన్ని కూడా తనిఖీ చేయవచ్చుj క్వెరీపై దాని వివిధ అనువర్తనాలతో పాటు లోతైన జ్ఞానాన్ని పొందండి, మీరు చేయవచ్చు 24/7 మద్దతు మరియు జీవితకాల ప్రాప్యతతో ప్రత్యక్ష ఆన్‌లైన్ శిక్షణ కోసం.పై కోడ్‌ను వేర్వేరు తీగలతో మరియు మార్పులతో అమలు చేయండి. ఇప్పుడు, పాయింటర్‌కు సంబంధించిన అన్ని ముఖ్య అంశాలపై మాకు మంచి అవగాహన ఉంది.
మాకు ప్రశ్న ఉందా? ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో వాటిని పేర్కొనండి మరియు మేము మిమ్మల్ని సంప్రదిస్తాము.