பொருளடக்கம்:
- C++ இல் லூப் என்றால் என்ன
- லூப்பின் தொடரியல்
- C++ இல் லூப் போது எப்படி பயன்படுத்துவது
- C++ Nested while Loop
- C++ Infinite while Loop
- C++ இல் லூப்களில் இரட்டை மற்றும் ஒற்றைப்படை எண்களை அச்சிடுதல்
- முடிவுரை
C++ இல் லூப் என்றால் என்ன
A while loop என்பது ஒரு கட்டுப்பாட்டு அமைப்பாகும், இது நிபந்தனை சரி என மதிப்பிடும் வரை தொடர்ந்து இயங்கும், மேலும் நிபந்தனை தவறானதாக மாறியவுடன் அது நிறுத்தப்படும். ஒரு குறிப்பிட்ட நிபந்தனை பூர்த்தியாகும் வரை நீங்கள் ஒரு குறிப்பிட்ட பணியை மீண்டும் செய்ய விரும்பும் சந்தர்ப்பங்களில் இது பயனுள்ளதாக இருக்கும்.
உதாரணத்திற்கு , 1 முதல் 10 வரையிலான எண்களை அச்சிடுவதற்கு நேர வளையத்தைப் பயன்படுத்தலாம் அல்லது கொடுக்கப்பட்ட எண்ணின் காரணியாலானதைக் கணக்கிடலாம்.
லூப்பின் தொடரியல்
C++ இல் சிறிது நேர சுழற்சியின் அடிப்படை தொடரியல் பின்வருமாறு:
போது ( நிலை ) {
// குறியீடு செயல்படுத்தப்பட வேண்டும்
}
நிபந்தனை உண்மையாக இருக்கும் வரை சுருள் பிரேஸ்களுக்குள் உள்ள குறியீடு மீண்டும் மீண்டும் செயல்படுத்தப்படும். லூப் இயங்கும் ஒவ்வொரு முறையும் நிலை சரிபார்க்கப்படும்.
C++ இல் லூப் போது எப்படி பயன்படுத்துவது
லூப்கள் தொடக்கப் புள்ளியிலிருந்து இறுதிப் புள்ளி வரை எண்ணப்படுகின்றன என்பதற்கான பொதுவான எடுத்துக்காட்டுகளில் ஒன்று. உதாரணத்திற்கு, பின்வரும் குறியீடு 1 முதல் 10 வரை கணக்கிடப்படும்:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக நான் = 1 ; // எதிர் மாறியை 1க்கு துவக்கவும்
கவுண்டர் மாறி 10 ஐ விட குறைவாகவோ அல்லது சமமாகவோ இருக்கும்போது // லூப்
போது ( நான் <= 10 ) {
கூட் << நான் << endl ; // எதிர் மாறியின் தற்போதைய மதிப்பை வெளியிடவும்
நான் ++; // எதிர் மாறியை அதிகரிக்கவும்
}
திரும்ப 0 ;
}
இந்த குறியீடு C++ இல் ஒரு வேளை வளையத்தை எவ்வாறு பயன்படுத்துவது என்பதை விளக்குகிறது. நிரல் ஒரு எதிர் மாறியை துவக்குகிறது நான் 1 க்கு பின்னர் சிறிது நேர சுழற்சியை இயக்குகிறது, அது வரை தொடர்ந்து இயங்கும் நான் 10 ஐ விட அதிகமாகிறது.
while லூப்பின் உள்ளே, எதிர் மாறியின் தற்போதைய மதிப்பு கன்சோலில் அச்சிடப்படுகிறது கூட் ஸ்டேட்மென்ட், அதைத் தொடர்ந்து ஒரு வரி முறிவு பயன்படுத்தி endl . எதிர் மாறி பின்னர் 1 ஐப் பயன்படுத்தி அதிகரிக்கப்படுகிறது நான்++ அறிக்கை.
எதிர் மாறி வரை லூப் தொடர்ந்து இயங்கும் நான் 11 இன் மதிப்பை அடைகிறது, அந்த நேரத்தில் லூப் வெளியேறும் மற்றும் நிரல் 0 இன் ரிட்டர்ன் மதிப்புடன் முடிவடைகிறது.
C++ Nested while Loop
அதே நேரத்தில் சுழல்கள் கூட இருக்கலாம் கூடு கட்டப்பட்டது , அதாவது நீங்கள் ஒரு போது லூப்பை மற்றொரு போது வளையத்திற்குள் வைத்திருக்கலாம். ஒரு குறிப்பிட்ட நிபந்தனையை பூர்த்தி செய்யும் வரை நீங்கள் ஒரு பணியை மீண்டும் மீண்டும் செய்ய வேண்டிய சந்தர்ப்பங்களில் இது பயனுள்ளதாக இருக்கும், மேலும் அந்த பணிக்குள், வேறு நிபந்தனை பூர்த்தியாகும் வரை நீங்கள் மீண்டும் மீண்டும் மற்றொரு பணியைச் செய்ய வேண்டும்.
உள்ளமைக்கப்பட்ட போது வளையத்தில், வெளிப்புற வளையம் ஒரு முறை செயல்படுத்தப்படும், பின்னர் வெளிப்புற வளையம் இயங்கும் ஒவ்வொரு முறையும் உள் சுழற்சியை இயக்கும். வெளிப்புற சுழற்சியின் ஒவ்வொரு மறு செய்கைக்கும் உள் வளையம் ஒருமுறை முழுமையாக செயல்படுத்தப்படுகிறது.
உதாரணமாக
C++ இல் Nested while loop ஐப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு குறியீடு பின்வருமாறு:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக நான் = 1 ; // எதிர் மாறியை 1க்கு துவக்கவும்
// லூப் போது கவுண்டர் மாறி 3 ஐ விட குறைவாக அல்லது சமமாக உள்ளது
போது ( நான் <= 3 ) {
முழு எண்ணாக ஜே = 1 ; // உள் கவுண்டர் மாறியை 1 க்கு துவக்கவும்
உள் கவுண்டர் மாறி 3க்கு குறைவாகவோ அல்லது சமமாகவோ இருக்கும்போது // லூப்
போது ( ஜே <= 3 ) {
கூட் << நான் << '' << ஜே << ' \n ' ; // எதிர் மாறிகளின் தற்போதைய மதிப்புகளை வெளியிடவும்
ஜே ++; // இன்க்ரிமெண்ட் உள் கவுண்டர் மாறி
}
நான் ++; // அதிகரிப்பு வெளிப்புற கவுண்டர் மாறி
}
திரும்ப 0 ;
}
இந்தக் குறியீட்டில், அவுட்டர் லூப் நீளமாக இயங்கும் நான் மதிப்பானது 3 க்கு சமமாக மாறும் நான் 3 ஐ விட அதிகமாகி லூப் நின்றுவிடும். ஒவ்வொரு வெளிப்புற லூப் மறு செய்கையிலும், உள் கவுண்டர் மாறி ஜே 1 க்கு துவக்கப்பட்டு உள் வளைவை இயக்குகிறது. இன் மதிப்பு வரை இந்த உள் சுழற்சி இயங்கும் ஜே விட அதிகமாகிறது 3 .
உள் சுழற்சியின் உள்ளே, நாம் மதிப்புகளை வெளியிடுகிறோம் நான் மற்றும் ஜே . அதன் பிறகு, நாங்கள் அதிகரித்தோம் ஜே . உள் வளையம் மூன்று முறை செயல்படுத்தப்படும் வரை இது தொடர்கிறது. ஒவ்வொரு முறையும் வெளிப்புற வளையம் அதிகரிக்கப்படும்போது, உள் வளையமும் மீண்டும் செயல்படுத்தப்படும்.
வெளிப்புற வளையம் மூன்று முறை செயல்படுத்தப்பட்டு இரண்டு சுழல்களும் முடிவடையும் வரை இந்த செயல்முறை மீண்டும் நிகழ்கிறது. இந்தக் குறியீட்டின் வெளியீடு, கீழே உள்ள படத்தில் காட்டப்பட்டுள்ளபடி, 1 1 முதல் 3 3 வரையிலான மதிப்புகளின் அட்டவணையாகும்.
C++ Infinite while Loop
C++ இல் infinite while loops கூட சாத்தியமாகும். வரையறுக்கப்பட்ட எந்த நிபந்தனையும் தவறானதாக இருக்க முடியாது என்பதால், எல்லையற்ற போது வளையம் தொடர்ந்து இயங்கும். ஒரே ஒரு உண்மை நிலை உள்ளது , இது while loop ஐ எண்ணற்ற முறை தொடர்ந்து இயக்க அனுமதிக்கிறது.
உதாரணத்திற்கு , கீழே கொடுக்கப்பட்டுள்ள லூப் என்றென்றும் இயங்கும் மற்றும் இந்த லூப்பை நிறுத்த இந்த லூப்பின் முடிவில் ஒரு பிரேக் ஸ்டேட்மெண்ட்டை வரையறுக்க வேண்டும்.
போது ( உண்மை ) {// குறியீடு செயல்படுத்தப்பட வேண்டும்
}
உட்பொதிக்கப்பட்ட அமைப்புகளில் அல்லது பயனர் உள்ளீட்டிற்காக காத்திருக்கும் போது, சில சமயங்களில் எல்லையற்ற வளையம் பயனுள்ளதாக இருக்கும்.
உதாரணமாக
C++ குறியீட்டில் ஒரு infinite while loopஐ இயக்கும் உதாரணம் C++ நிரல் கீழே உள்ளது:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக எண்ணிக்கை = 0 ;
போது ( உண்மை ) {
கூட் << 'இன்ஃபினிட்டிவ் வைல் லூப் \n ' ;
எண்ணிக்கை ++;
என்றால் ( எண்ணிக்கை >= 10 ) {
உடைக்க ;
}
}
திரும்ப 0 ;
}
கொடுக்கப்பட்ட குறியீடானது, 'இன்ஃபினிட்டிவ் வைல் லூப்' சரத்தை கன்சோலில் தொடர்ந்து வெளியிடும் ஒரு எல்லையற்ற வளையத்தை உருவாக்குகிறது. ஏனென்றால், லூப்பின் நிபந்தனை உண்மையாக அமைக்கப்பட்டுள்ளது, இது எப்போதும் உண்மையான லூப் முடிவடையாது.
ஒரு முடிவிலா வளையத்தை நிறுத்த, ஒரு குறிப்பிட்ட நிபந்தனையை சந்திக்கும் போது, லூப்பில் இருந்து வெளியேற, இடைவெளி அறிக்கையைப் பயன்படுத்தலாம். மேலே உள்ள திட்டத்தில், அதிகபட்ச மறு செய்கைகளின் எண்ணிக்கையை 10 ஆக அமைத்துள்ளோம் எண்ணிக்கை மாறி மற்றும் இடைவெளி அறிக்கை.
மேலே உள்ள குறியீடு எண்ணற்ற முறை இயங்கும், ஆனால் இடைவேளை அறிக்கையைப் பயன்படுத்துவது 10 மறுமுறைகளுக்குப் பிறகு நிறுத்தப்படும்.
லூப் உடன் இரட்டை மற்றும் ஒற்றைப்படை எண்களை அச்சிடுதல்
லூப்கள் சம மற்றும் ஒற்றைப்படை எண்களை அச்சிடுகின்றன என்பதற்கு மற்றொரு எடுத்துக்காட்டு. உதாரணத்திற்கு , பின்வரும் கொடுக்கப்பட்ட குறியீடு 2 முதல் 10 வரையிலான இரட்டை எண்களை வெளியிடுவதற்கு C++ இல் சிறிது நேர சுழற்சியைப் பயன்படுத்துகிறது.
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக நான் = 2 ; // எதிர் மாறியை 2க்கு துவக்கவும்
// லூப் போது கவுண்டர் மாறி 10 ஐ விட குறைவாக அல்லது சமமாக உள்ளது
போது ( நான் <= 10 ) {
கூட் << நான் << endl ; // எதிர் மாறியின் தற்போதைய மதிப்பை வெளியிடவும்
நான் += 2 ; // எதிர் மாறியை 2 ஆல் அதிகரிக்கவும்
}
திரும்ப 0 ;
}
இந்த C++ குறியீடு எதிர் மாறியை துவக்குகிறது நான் 2 க்கு மற்றும் மதிப்பை மீண்டும் மீண்டும் வெளியிட, சிறிது நேர வளையத்தைப் பயன்படுத்துகிறது நான் 10ஐ விட குறைவாகவோ அல்லது சமமாகவோ இருக்கும் வரை. லூப்பின் ஒவ்வொரு மறு செய்கையிலும், அது அதிகரிக்கிறது நான் மூலம் 2. ஒவ்வொரு முறையும் லூப் இயங்கும் வெளியீடு முனையத்தில் அச்சிடப்படும். லூப் முடிந்ததும், நிரல் வெற்றிகரமான செயல்படுத்தலைக் குறிக்க 0 ஐ வழங்குகிறது.
இதேபோல், நாமும் அச்சிடலாம் ஒற்றைப்படை 1 முதல் 9 வரையிலான எண்கள்:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக நான் = 1 ; // எதிர் மாறியை 1க்கு துவக்கவும்
// லூப் போது கவுண்டர் மாறி 9 ஐ விட குறைவாக அல்லது சமமாக உள்ளது
போது ( நான் <= 9 ) {
கூட் << நான் << endl ; // எதிர் மாறியின் தற்போதைய மதிப்பை வெளியிடவும்
நான் += 2 ; // எதிர் மாறியை 2 ஆல் அதிகரிக்கவும்
}
திரும்ப 0 ;
}
இந்த குறியீட்டில், கவுண்டர் மாறி வரை லூப் நிலை இயங்கும் நான் 9 ஐ விட குறைவாக அல்லது சமமாக உள்ளது கூட் லூப்பில் உள்ள அறிக்கை தற்போதைய மதிப்பை வெளியிடுகிறது நான் , பின்னர் தி நான் மாறியைப் பயன்படுத்தி 2 ஆல் அதிகரிக்கப்படுகிறது i += 2 அறிக்கை. ஒற்றைப்படை எண்கள் மட்டுமே வளையத்தால் அச்சிடப்படுவதை இது உறுதி செய்கிறது.
நிரலின் முடிவில், முக்கிய() செயல்பாடு நிறைவடைந்ததைக் குறிக்க ரிட்டர்ன் ஸ்டேட்மெண்ட் பயன்படுத்தப்படுகிறது.
முடிவுரை
A while loop என்பது ஒரு கட்டுப்பாட்டு கட்டமைப்பாகும், இது வரையறுக்கப்பட்ட நிபந்தனை உண்மையாக இருக்கும் வரை ஒரு நிரலை இயக்குகிறது. இங்கே நாம் அடிப்படை தொடரியல் மற்றும் C++ இல் லூப்களைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டுகளை உள்ளடக்கியுள்ளோம். உள்ளமைக்கப்பட்ட வடிவத்தில் ஒரு வேளை வளையத்தை எவ்வாறு பயன்படுத்துவது மற்றும் எண்ணற்ற முறை லூப் செய்யும் போது ஒருவர் எவ்வாறு இயக்கலாம் என்பதையும் நாங்கள் விவரிக்கிறோம். C++ while loop பற்றிய கூடுதல் விவரங்களுக்கு, கட்டுரையைப் படிக்கவும்.