C++ இல், லூப் அறிக்கைகள் ஒரு குறிப்பிட்ட குறியீடு அல்லது அறிக்கையை மீண்டும் செய்கின்றன. ஒரே செயல்பாட்டை ஒன்றுக்கு மேற்பட்ட முறை செய்வதன் மூலம் குறியீட்டைச் சுருக்கவும் மற்றும் பணிநீக்கத்தைக் குறைக்கவும் அவை பெரும்பாலும் பயன்படுத்தப்படுகின்றன. லூப்களுக்கு, லூப்கள் மற்றும் டூ-வைல் லூப்கள் ஆகியவை C++ ஆல் ஆதரிக்கப்படும் லூப் வகைகளில் சில மட்டுமே. ஒவ்வொன்றுக்கும் ஒரு தனித்துவமான தொடரியல், நன்மைகள் மற்றும் பயன்பாடு உள்ளது. குறியீட்டின் தொகுதியை மீண்டும் மீண்டும் இயக்க விரும்பும்போது, லூப் எனப்படும் நிரலாக்கக் கட்டுப்பாட்டு அமைப்பைப் பயன்படுத்துகிறோம். பொதுவாக, அது இயங்கிக்கொண்டே இருக்கும் மற்றும் ஒரு குறிப்பிட்ட அளவுகோல் பூர்த்தி செய்யப்படும்போது நின்றுவிடும். இந்த இடுகையில் ஒரு முக்கியமான யோசனையை நீங்கள் கண்டுபிடிப்பீர்கள், அதாவது C++ For Loop.
C++ இல் லூப் என்றால் என்ன?
இந்த மறுமுறை கட்டுப்பாட்டு அமைப்பு C++ குறியீட்டின் ஒரு குறிப்பிட்ட பகுதியில் மீண்டும் மீண்டும் லூப் செய்ய உதவுகிறது. சோதனை வெளிப்பாடு உண்மையாக இருந்தால், ஒரு for loop செயல்படுத்தப்படும். சோதனை வெளிப்பாடு தவறானதாக இருந்தால், லூப் இயங்குவதை நிறுத்துகிறது. ஒவ்வொரு மறு செய்கைக்கும் முன், நிலைமையை சரிபார்க்க வேண்டும். மதிப்பீடு உண்மையான முடிவை உருவாக்கினால், லூப்பின் உடல் இயங்கும்.
லூப்பிற்கான தொடரியல்
கீழே, C++ மொழியில் for loop இன் தொடரியல் குறிப்பிட்டுள்ளோம்.
'init வெளிப்பாடு' என்பது முதல் அளவுரு. இந்த வெளிப்பாட்டில் ஒரு குறிப்பிட்ட எண்ணுக்கு லூப் கவுண்டரை துவக்க வேண்டும். உதாரணமாக, int i=1.
‘நிபந்தனை’ என்பது இரண்டாவது அளவுரு. நாம் இங்கே நிலைமையை சோதிக்க வேண்டும். அளவுகோல் பூர்த்தி செய்யப்பட்டால், for loop தொடரும்; அது இல்லை என்றால், அது முடிவடையும். அடுத்த எடுத்துக்காட்டில், i <= 5. அதிகரிப்பு என்பது மூன்றாவது மற்றும் கடைசி அளவுருவாகும். இந்த வெளிப்பாடு லூப் பாடி இயங்கிய பிறகு லூப் மாறியை ஒரு குறிப்பிட்ட எண்ணால் அதிகரிக்கிறது/குறைக்கிறது. உதாரணமாக: i++;.
இப்போது for loop பற்றி விவாதிக்கும் சில நிரலாக்க எடுத்துக்காட்டுகளைப் பார்ப்போம்.
எடுத்துக்காட்டு 1:
எங்கள் முதல் எடுத்துக்காட்டில், முதல் 15 இயற்கை முழு எண்களை அச்சிட ஃபார் லூப்பைப் பயன்படுத்தினோம். for loop எவ்வாறு செயல்படுகிறது என்பதைக் காட்ட, இணைக்கப்பட்ட குறியீட்டைப் பார்க்கவும்.
குறியீட்டில் iostream தலைப்பு கோப்பு செருகப்பட்ட பிறகு முக்கிய முறை தொடங்கப்பட்டது. ஒரு எண் தொடங்கப்பட்டது, அது 15 ஐ விடக் குறைவாகவோ அல்லது சமமாகவோ உள்ளதா என்பதைப் பார்க்க ஒரு நிபந்தனை எழுதப்படுகிறது. for loop இல் ஒவ்வொரு ரிப்பீட் செய்த பிறகும் எண்ணிக்கை அதிகரிக்கப்படுகிறது. குறியீட்டில், (எண்=4; எண்=15; எண்++) என எழுதப்பட்டுள்ளது.
நிபந்தனை 'எண் <= 15' ஆய்வு செய்யப்பட்டது. நிபந்தனை திருப்திகரமாக இருந்தால், லூப்பின் உடலில் எழுதப்பட்ட அறிக்கைகள் செயல்படுத்தப்படும். நிபந்தனை தவறானதாக இருந்தால், லூப்பில் எழுதப்பட்ட அறிக்கைகளை நிரல் செயல்படுத்தும். ஃபார் லூப்பின் குறியீட்டின் செயல்பாட்டிற்குப் பிறகு, 'நம்பர்++' கட்டளை இயக்கப்படுகிறது. இந்த விளக்கப்படத்தில், ஒவ்வொரு முறை for loop இன் உடல் குறியீடு செயல்படுத்தப்படும்போதும், 'எண்' இன் மதிப்பு 1 ஆல் உயர்கிறது. ஒவ்வொரு லூப்பிற்குப் பிறகும் நீங்கள் இயக்க விரும்பும் எந்த வெளிப்பாடுகளையும் இங்கே பயன்படுத்தலாம்.
மேலே உள்ள எடுத்துக்காட்டில், “எண் = 4” என்பது “எண்” என்ற மாறிக்கு 4 மதிப்பைக் கொடுக்கிறது. அடுத்து, “எண்<=15” நிபந்தனை ஆராயப்படுகிறது. 'எண்' இன் மதிப்பு 4 ஆக இருப்பதால் for loop இன் உடலில் உள்ள குறியீடு செய்யப்படுகிறது. இதன் விளைவாக, 'எண்' இன் தற்போதைய மதிப்பு 4 அச்சிடப்படுகிறது.
for loop இன் குறியீடுகள் இயக்கப்பட்ட பிறகு, படி 'எண்++' இயக்கப்படுகிறது, இது 'எண்' இன் மதிப்பை 1 ஆல் உயர்த்துகிறது. எனவே, 5 என்பது 'எண்' என்ற மாறியின் புதிய மதிப்பாகும்.
'எண்<=15' நிபந்தனை மீண்டும் ஒருமுறை சரிபார்த்து, உண்மை என கண்டறியப்பட்டது, ஏனெனில் 'எண்' இன் மதிப்பு 5. லூப்பின் உடல் குறியீடு மீண்டும் இயக்கப்பட்டால், 5 அச்சிடப்படும். பின்னர், 'எண்' மதிப்பு மீண்டும் ஒருமுறை அதிகரிக்கப்படுகிறது.
'எண்' இன் மதிப்பு 15 ஆக மாற்றப்படும் போது, 'எண் <= 15' என்ற வெளிப்பாடு சரி என மதிப்பிடுகிறது, 15 ஐ அச்சிடுகிறது. 'எண்<=15' நிபந்தனை இப்போது தவறானதாக மாறும் மற்றும் எண்++ 'எண்ணின் மதிப்பை உயர்த்தும் போது லூப் முடிவடைகிறது. ” முதல் 16 வரை.
#முழு எண்ணாக முக்கிய ( )
{
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக எண் ;
க்கான ( எண் = 4 ; எண் <= பதினைந்து ; எண் ++ )
{
கூட் << எண் << endl ;
}
திரும்ப 0 ;
}
ஃபார் லூப்பைப் பயன்படுத்தி 4 முதல் 15 வரையிலான எண்கள் அச்சிடப்பட்டதைக் காணக்கூடிய வெளியீடு இங்கே உள்ளது.
எடுத்துக்காட்டு 2:
நேர்மறை எண்ணின் காரணியை நாம் தீர்மானிக்கும் இரண்டாவது எடுத்துக்காட்டு இதுவாகும். முதலில், iostream தலைப்பு கோப்பு எங்கள் குறியீட்டில் இணைக்கப்பட்டுள்ளது. இந்த கோப்பு கன்சோலில் இருந்து படிக்கவும் எழுதவும் அனுமதிக்கும். பின்னர், அதன் வகுப்புகள் மற்றும் செயல்பாடுகளை அழைக்காமல் அணுக, நாங்கள் std பெயர்வெளியைச் சேர்த்துள்ளோம். நிரலின் தர்க்கத்தைக் கொண்டிருக்க வேண்டிய முக்கிய() முறை, குறியீட்டின் பின்வரும் வரியில் அழைக்கப்படுகிறது. முக்கிய() செயல்பாட்டின் உடல் என்பது { அதன் தொடக்கத்தைக் குறிக்கிறது. இங்கே, முழு எண் மாறிகள் a, n மற்றும் உண்மை அறிவிக்கப்பட்டுள்ளன. உண்மை மாறிக்கு 1 மதிப்பு அமைக்கப்பட்டுள்ளது. கன்சோலில், சில உரைகளை அச்சிட்டுள்ளோம். 'எந்த நேர்மறை எண்ணையும் தட்டச்சு செய்யவும்:' உரையில் எழுதப்பட்டுள்ளது.
உரையில் உள்ள மாறி எண்ணுக்கு மதிப்பை உள்ளிடுமாறு பயனர் கேட்கப்படுவார். ஒரு வளையம் பின்னர் கட்டப்பட்டது. துவக்கத்தின் போது 'a' என்ற பெயரிடப்பட்ட முழு எண் மாறி உருவாக்கப்பட்டது மற்றும் அதற்கு 1 இன் மதிப்பு வழங்கப்படுகிறது. 'n' மாறியின் மதிப்பை விட a இன் மதிப்பு அதிகமாகவோ அல்லது சமமாகவோ இருக்கக்கூடாது என்று நிபந்தனை கூறுகிறது. ஒவ்வொரு மறு செய்கைக்குப் பிறகும், அதிகரிப்பு 'a' இன் மதிப்பை 1 ஆல் உயர்த்துகிறது. ஃபார்-லூப்பின் உடல் சின்னம் () மூலம் அறிமுகப்படுத்தப்படுகிறது. ஃபார்முலா உண்மை = உண்மை * a பின்வரும் குறியீட்டில் காரணி மதிப்பைக் கணக்கிட பயன்படுத்தப்பட்டது. சுழற்சி பின்னர் முடிவுக்கு வருகிறது.
'n' மற்றும் 'fact' மாறிகளின் மதிப்புகள் பின்வரும் வரியில் கூடுதல் உரையுடன் கன்சோலில் அச்சிடப்படும். நிரல் வெற்றிகரமாக இயங்கினால், முக்கிய() செயல்பாடு ஒரு மதிப்பை வழங்குகிறது. இறுதியாக, முக்கிய () செயல்பாட்டின் உடலின் முடிவைக் காணலாம். முழு குறியீடும் இங்கே:
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக a, n, உண்மை = 1 ;
கூட் <> n ;
க்கான ( அ = 1 ; அ <= n ; ++ அ )
{
உண்மை * = அ ;
}
கூட் << 'இங்கே காரணியாலானது' << n << ' = ' << உண்மை ;
திரும்ப 0 ;
}
மேலே உள்ளவற்றை இயக்கும் போது, அது முதலில் ஏதேனும் நேர்மறை எண்ணை வழங்குமாறு பயனரைத் தூண்டும். அவ்வாறு செய்யும்போது, அந்த எண்ணின் காரணியாலானது வழங்கப்படுகிறது.
இங்கே, கொடுக்கப்பட்ட எண்ணின் காரணியாலானது எங்கள் விஷயத்தில் 5 என்பதைக் காணலாம்.
முடிவுரை
இந்தக் கட்டுரையில் C++ for loop பற்றிய விவரங்களை வழங்கியுள்ளோம். ஒரு குறிப்பிட்ட நிபந்தனையை பூர்த்தி செய்யும் வரை, ஒரு லூப்பில் அறிக்கைகளின் தொகுப்பு தொடர்ந்து செயல்படுத்தப்படுகிறது. உங்கள் உதவிக்காக, நாங்கள் இரண்டு முழுமையான உதாரணங்களையும் வழங்கியுள்ளோம்.