சி இல் லூப்பிற்கு சிறந்த முறையில் செயல்படுத்துவது எப்படி?

ஃபார் லூப் இன் சி பற்றிய இந்த கட்டுரையில், அடிப்படை தொடரியல் முதல் அதை செயல்படுத்தும் பல்வேறு வழிகள் வரை எல்லாவற்றையும் பற்றி ஆராய்வோம்.

ஃபார் லூப் இன் சி பற்றிய இந்த கட்டுரையில், ஃபார் லூப்ஸைப் பற்றிய எல்லாவற்றையும் ஆராய்வோம் அதை செயல்படுத்த பல்வேறு வழிகளில். இந்த கட்டுரையில் பின்வரும் சுட்டிகள் விவரிக்கப்படும்,



எனவே பின்னர் தொடங்குவோம்,



சி இல் லூப்பிற்கு

சிக்கலான சிக்கல்களை எளிதாக்குவதால் அனைத்து நிரலாக்க மொழிகளிலும் லூப் அடிப்படை கருத்துகளில் ஒன்றாகும். எளிமையான சொற்களில், கொடுக்கப்பட்ட நிபந்தனை தவறானதாக வரும் வரை லூப் ஒரே குறியீட்டின் தொகுப்பை பல முறை மீண்டும் செய்கிறது. எனவே, ஒரே குறியீட்டை மீண்டும் மீண்டும் எழுதுவதற்கு பதிலாக, ஒரே குறியீட்டை பல முறை இயக்க லூப்பைப் பயன்படுத்தலாம்.

எடுத்துக்காட்டாக, 1 முதல் 100 வரையிலான இயற்கை எண்களை அச்சிட, நீங்கள் 100 அச்சு அறிக்கைகளை எழுதலாம், அல்லது 100 மறு செய்கைகளுக்கு லூப்பை இயக்கலாம் மற்றும் இயற்கை எண்களை அச்சிடலாம். வெளிப்படையாக இரண்டாவது விருப்பம் எளிதானது மற்றும் மிகவும் சாத்தியமானது.



ஃபார் லூப் இன் சி கட்டுரையுடன் இதை நகர்த்துவது,

சி இல் சுழல்கள்

லூப் இரண்டு பகுதிகளைக் கொண்டுள்ளது:

  • உடல் சுழற்சி: தொடர்ச்சியாக செயல்படுத்தப்பட வேண்டிய அறிக்கைகளின் தொகுப்பைக் கொண்டுள்ளது
  • நிபந்தனை அறிக்கை : ஒரு நிபந்தனை. அது உண்மையாக இருந்தால், அடுத்த மறு செய்கை செயல்படுத்தப்படுகிறது, இல்லையெனில் மரணதண்டனை ஓட்டம் வளையிலிருந்து வெளியேறுகிறது.

சி இல் சுழற்சியின் வகைகள்



சி இல் இரண்டு வகையான சுழல்கள் உள்ளன, அதாவது நுழைவு கட்டுப்படுத்தப்பட்ட சுழல்கள் மற்றும் வெளியேறும் கட்டுப்படுத்தப்பட்ட சுழல்கள்.

  • நுழைவு கட்டுப்படுத்தப்பட்ட சுழல்கள்: நுழைவு கட்டுப்படுத்தப்பட்ட சுழல்கள் ஒரு சுழற்சியின் உடலை இயக்கும் முன் சோதனை நிலை சோதிக்கப்படும் அந்த சுழல்கள். For & while loop என்பது நுழைவு கட்டுப்படுத்தப்பட்ட சுழல்கள்.
  • கட்டுப்படுத்தப்பட்ட சுழல்களிலிருந்து வெளியேறு: வெளியேறு கட்டுப்படுத்தப்பட்ட சுழல்கள் என்பது ஒரு சுழற்சியின் உடலை இயக்கிய பின் சோதனை நிலை சோதிக்கப்படும் அந்த சுழல்கள் ஆகும். do-while loop என்பது வெளியேறும் கட்டுப்பாட்டு வளையமாகும்.

ஃபார் லூப் இன் சி கட்டுரையுடன் இதை நகர்த்துவது,

லூப் தொடரியல்

லூப் என்பது ஒரு வளையல் கட்டமைப்பாகும், இது கொடுக்கப்பட்ட நிபந்தனை தவறானதாக இருக்கும் வரை குறியீட்டின் வரிசையை இயக்க பயன்படுகிறது. மறு செய்கைகளின் எண்ணிக்கை முன்கூட்டியே அறியப்படும்போது லூப்பிற்குப் பயன்படுத்த சிறந்த நிபந்தனை.

தொடரியல்:

(துவக்க நிலை சோதனை அதிகரிப்பு அல்லது குறைவு) code // குறியீட்டின் தொகுதி மீண்டும் மீண்டும் செயல்படுத்தப்பட வேண்டும்}

ஃபார் லூப்பின் ஓட்ட வரைபடம்

லூப் - சி இன் லூப்பிற்கு - எடுரேகா

படி 1: செயல்படுத்தல் ஓட்டத்தில், முதலில் எதிர் மாறி துவக்கப்படும்.

படி 2: சோதனை நிலை சரிபார்க்கப்பட்டது, கொடுக்கப்பட்ட நிபந்தனைக்கு எதிர் மாறி சோதிக்கப்படுகிறது. நிபந்தனை உண்மையாகிவிட்டால், செயல்பாட்டு உடலுக்குள் இருக்கும் குறியீட்டின் தொகுதி செயல்படுத்தப்படும், இல்லையெனில் ஃபார் லூப் நிறுத்தப்படும் & கட்டுப்பாடு லூப்பிலிருந்து வெளியேறும்.

படி 3: செயல்பாட்டு உடலை வெற்றிகரமாக செயல்படுத்தினால், செயல்பாட்டின் அடிப்படையில் எதிர் மாறி அதிகரிக்கும் அல்லது குறைகிறது.

உதாரணமாக

# எண்ணை பிரதான () {int கவுண்டருக்கு (எதிர் = 1 கவுண்டருக்கு சேர்க்கவும்<=10 counter++) { printf('%dn', counter) } return 0 }

வெளியீடு:

ஃபார் லூப் இன் சி கட்டுரையுடன் இதை நகர்த்துவது,

சி இல் லூப்பிற்கான வெவ்வேறு வடிவங்கள்

  • எதிர் ++ & எதிர் + 1 ஒரே வெளியீட்டை அளிக்கிறது.

உதாரணமாக:

# எண்ணை பிரதான () {int கவுண்டருக்கு (எதிர் = 1 கவுண்டருக்கு சேர்க்கவும்<=10 counter=counter+1) { printf('%dn', counter) } return 0 }

வெளியீடு:

எதிர் மாறியின் துவக்கத்தை நீங்கள் தவிர்க்கலாம் மற்றும் அதை வளையத்திற்கு முன் அறிவிக்க முடியும்.

உதாரணமாக:

வரிசைப்படுத்தல் செயலாக்கத்தை இணைக்கவும் c ++
# எண்ணை முக்கிய () {int counter = 1 க்கு (எதிர்<=10 counter=counter+1) { printf('%dn', counter) } return 0 }

வெளியீடு:

எதிர் மாறியின் துவக்கத்தை நீங்கள் தவிர்க்கலாம், ஆனால் சோதனை நிலைக்கு முன் அரைக்காற்புள்ளி இருக்க வேண்டும், இல்லையெனில் அது தொகுப்பு பிழையை எறியும்.

கவுண்டரின் அதிகரிப்பு அல்லது குறைப்பதை நீங்கள் தவிர்க்கலாம். ஆனால் இந்த சூழ்நிலையில் ஃபார்-லூப் உடலுக்குள் கவுண்டரை அதிகரிக்க வேண்டும்.

ஆழமான நகல் vs ஆழமற்ற நகல் ஜாவா

உதாரணமாக:

# எண்ணை பிரதான () {int கவுண்டருக்கு (எதிர் = 1 கவுண்டருக்கு சேர்க்கவும்<=10) { printf('%dn', counter) counter=counter+1 } return 0 }

ஃபார் லூப் இன் சி கட்டுரையுடன் இதை நகர்த்துவது,

ஃபார் லூப்பில் நீங்கள் நிபந்தனையைத் தவிர்க்கலாம், இதன் விளைவாக எல்லையற்ற வளையம் ஏற்படும்.

உதாரணமாக:

# எண்ணை பிரதான () {எண்ணை எதிர் (எதிர் = 1 எதிர் ++) {printf ('% dn', எதிர்)} திரும்ப 0}

வெளியீடு:

இன்ஃபின்ட் லூப்

லூப்பிற்கு ஒன்றுக்கு மேற்பட்ட மாறிகளை நாம் துவக்கலாம்.

உதாரணமாக:

# எண்ணை பிரதான () {int x, y, z (x = 1, y = 2, z = 3 x<5 x++, y++, z++) { printf('x %dn', x) printf('y %dn', y) printf('z %dn', z) } return 0 }

வெளியீடு:

ஃபார் லூப் இன் சி கட்டுரையுடன் இதை நகர்த்துவது,

சி இல் லூப்பிற்காக அமைந்துள்ளது

சி-யில் லூப்பிற்காக ஒன்றை லூப்பிற்குள் வைக்கலாம். இது லூஸ்டுக்கு நெஸ்டட் என்று அழைக்கப்படுகிறது.

உதாரணமாக:

# அடங்கும் # int int () {int i, k, rows, வெற்று printf ('வரிசைகளின் எண்ணிக்கையை உள்ளிடுக:') scanf ('% d', & வரிசைகள்) හිස් = வரிசைகள் (i = 1 i<= rows i++ ) { for ( k = 1 k < blank k++ ) printf(' ') blank-- for ( k = 1 k <= 2*i - 1 k++ ) printf('*') printf('n') } return 0 }

உதாரணமாக:

ஃபார் லூப் இன் சி கட்டுரையுடன் இதை நகர்த்துவது,

சுழல்களுக்கு வெளியே குதித்தல்

பல்வேறு சூழ்நிலைகளில், குறிப்பிட்ட நிபந்தனை பூர்த்தி செய்யப்படும்போது நீங்கள் வட்டத்திலிருந்து வெளியேற வேண்டும் அல்லது சுழற்சியின் மறு செய்கையைத் தவிர்க்க வேண்டும். எனவே, அந்த காட்சிகளில் வளையத்திலிருந்து வெளியேறுவது என்று அழைக்கப்படுகிறது. நீங்கள் அதை அடைய இரண்டு வழிகள் உள்ளன.

முறிவு அறிக்கை

ஒரு வட்டத்திற்குள் பிரேக் ஸ்டேட்மென்ட் எதிர்கொள்ளும்போது, ​​லூப் உடனடியாக வெளியேறும் மற்றும் நிரல் லூப்பைத் தொடர்ந்து உடனடியாக அறிக்கையுடன் தொடர்கிறது.

உள்ளமை வளையத்தின் விஷயத்தில், உட்புற சுழற்சியில் இடைவெளி அறிக்கை ஏற்பட்டால், உள் வளையம் வெளியேறும்.

உதாரணமாக:

# எண்ணை பிரதான () {int கவுண்டருக்கு (எதிர் = 1 கவுண்டருக்கு சேர்க்கவும்<=10 counter++) { if(counter==5) { break } printf('%dn', counter) } return 0 }

வெளியீடு:

வெளியீடு - சி இன் சுழலுக்கு - எடுரேகா

அறிக்கையைத் தொடரவும்

தொடர் அறிக்கை கட்டுப்பாட்டை நேரடியாக சோதனை நிலைக்கு அனுப்புகிறது, பின்னர் லூப் செயல்முறையைத் தொடரவும்.

தொடர்ச்சியான திறவுச்சொல்லை எதிர்கொள்ளும்போது, ​​செயல்படுத்தல் ஓட்டம் தற்போதைய சுழற்சியின் சுழற்சியை விட்டு, அடுத்த மறு செய்கையுடன் தொடங்குகிறது.

உதாரணமாக:

# எண்ணை பிரதான () {int கவுண்டருக்கு (எதிர் = 1 கவுண்டருக்கு சேர்க்கவும்<=10 counter++) { if(counter%2==1) { continue } printf('%dn', counter) } return 0 }

வெளியீடு:

வெளியீடு - சி இன் சுழலுக்கு - எடுரேகா

இதன் மூலம் ‘ஃபார் லூப் இன் சி’ இல் இந்த வலைப்பதிவின் இறுதியில் வருகிறோம். இந்த தகவலறிந்த மற்றும் பயனுள்ளதாக நீங்கள் கண்டறிந்தீர்கள் என்று நம்புகிறேன், இதே போன்ற தலைப்புகளில் கூடுதல் பயிற்சிகளுக்காக காத்திருங்கள்.நீங்கள் எங்கள் பயிற்சி திட்டத்தையும் பார்க்கலாம்jQuery இல் அதன் பல்வேறு பயன்பாடுகளுடன் ஆழ்ந்த அறிவைப் பெறலாம் 24/7 ஆதரவு மற்றும் வாழ்நாள் அணுகலுடன் நேரடி ஆன்லைன் பயிற்சிக்கு.மேலே உள்ள குறியீட்டை வெவ்வேறு சரங்கள் மற்றும் மாற்றங்களுடன் செயல்படுத்தவும். இப்போது, ​​சுட்டிக்காட்டி தொடர்பான அனைத்து முக்கிய கருத்துகளையும் பற்றி எங்களுக்கு நல்ல புரிதல் உள்ளது.

எங்களுக்கு ஒரு கேள்வி கிடைத்ததா? இந்த வலைப்பதிவின் கருத்துகள் பிரிவில் அவற்றைக் குறிப்பிடுங்கள், நாங்கள் உங்களைத் தொடர்புகொள்வோம்.