பற்றி மேலும் அறிய படிக்கவும் லூப் போது C++ இல்.
C++ இல் லூப் என்றால் என்ன?
C++ புரோகிராமிங்கில், a இன் மற்றொரு பெயர் லூப் போது முன் சோதனை செய்யப்பட்ட வளையமாகும். லூப்பின் நிபந்தனை உண்மையாக இருக்கும் வரை, ஒரு குறிப்பிட்ட தொகுதிக்குள் குறியீட்டு அறிக்கைகளை மீண்டும் மீண்டும் இயக்க நிரலை இது அனுமதிக்கிறது. லூப் முதலில் நிலைமையை சோதிக்கிறது; நிபந்தனை உண்மையாக இருந்தால், லூப் அடைப்புக்குறிக்குள் உள்ள குறியீடு முதலில் செயல்படுத்தப்படும் மற்றும் லூப் மீண்டும் மீண்டும் குறியீட்டை இயக்கும், குறிப்பிட்ட நிபந்தனை தவறானதாக மாறும்போது, லூப்பின் அடைப்புக்குறிக்குள் உள்ள குறியீடு மற்றும் அறிக்கைகள் இனி செயல்படுத்தப்படாது.
போது லூப்பின் கூறுகள்
இன் அத்தியாவசிய கூறுகள் லூப் போது சேர்க்கிறது:
- போது முக்கிய வார்த்தை
- சோதனை நிலை
- அறிக்கைகள்
- அதிகரிப்பு அல்லது குறைப்பு
லூப் க்கான தொடரியல்
என்ற தொடரியல் லூப் போது C++ இல் பின்வருமாறு:
போது ( நிலை சோதனை )
{
//திரும்பத் திரும்ப செயல்படுத்த வேண்டிய அறிக்கைகள்
// அதிகரிப்பு (++) அல்லது குறைப்பு (--) செயல்பாடு
}
கீழே உள்ள ஓட்ட வரைபடம் லூப் போது :
C++ இல் லூப் போது எப்படி பயன்படுத்துவது
நாம் அச்சிட விரும்பும் உதாரணத்தைக் கவனியுங்கள் 'லினக்ஸ்' பத்து மடங்கு. 'printf' அறிக்கையை பத்து முறை தட்டச்சு செய்வதற்கு பதிலாக, நாம் பயன்படுத்தலாம் லூப் போது பத்து மறுமுறைகள் வரை இயக்க. இங்கே ஒரு உதாரணம்:
#
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக எண்ணிக்கை = 0 ;
போது ( எண்ணிக்கை < 10 ) {
கூட் << 'லினக்ஸ் \n ' ;
எண்ணிக்கை ++;
}
திரும்ப 0 ;
}
மேலே உள்ள குறியீடானது, செய்தியை அச்சிடுவதற்கு நேர சுழற்சியைப் பயன்படுத்துகிறது 'லினக்ஸ்' 10 முறை. இது ஒரு எதிர் மாறியை 0 க்கு துவக்குகிறது, பின்னர் 10 ஐ அடையும் வரை கவுண்ட் அறிக்கையை இயக்க மற்றும் கவுண்டரை அதிகரிக்க while லூப்பைப் பயன்படுத்துகிறது.
C++ இல் லூப் செய்யும் போது Infinite ஐ எவ்வாறு பயன்படுத்துவது
சில சந்தர்ப்பங்களில், தி லூப் போது ஒருபோதும் ஓடக்கூடாது. லூப்பின் நிலை தவறானதாக மாறும்போது, லூப் முடிவடைகிறது, மேலும் வளையத்திற்குப் பிறகு முதல் அறிக்கை அச்சிடப்படும். நீங்கள் infinite while loop ஐப் பயன்படுத்த விரும்பினால், எப்போதும் உண்மையாக இருக்கும் நிபந்தனையைச் சேர்க்கவும். எடுத்துக்காட்டாக, முழு எண் “a” இன் மதிப்பு எப்போதும் 10 ஐ விட அதிகமாக இருக்கும், இதனால் லூப் முடிவடையாது:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக அ = 10 ;
போது ( அ >= 10 )
{
கூட் << அ << ' \n ' ;
அ ++;
}
திரும்ப 0 ;
}
குறிப்பு: எப்போதும் உண்மையாக இருக்கும் ஒரு நிபந்தனையைக் குறிப்பிடுவதற்குப் பதிலாக, 'உண்மை' முக்கிய சொல்லை சிறிது நேர வளையத்துடன் பயன்படுத்தலாம்.
லூப்பில் லாஜிக்கல் ஆபரேட்டர்களை எப்படி பயன்படுத்துவது - சி++
தருக்க ஆபரேட்டர்கள் விரும்புகிறார்கள் மற்றும் (&&) மற்றும் அல்லது (||) யிலும் பயன்படுத்தலாம் லூப் போது . நீங்கள் AND ஆபரேட்டரைப் பயன்படுத்தினால், இரண்டு நிபந்தனைகளும் சரியாக இருக்க வேண்டும் லூப் போது , மற்றும் நீங்கள் பயன்படுத்தினால் அல்லது ஆபரேட்டர், இரண்டு நிபந்தனைகளும் தவறாகத் திரும்பும் வரை லூப் இயங்கும்.
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக எக்ஸ் = 1 , மற்றும் = 1 ;
போது ( ( எக்ஸ் <= 5 && மற்றும் <= 5 ) || எக்ஸ் + மற்றும் <= 10 ) {
கூட் << 'எக்ஸ்: ' << எக்ஸ் << ', மற்றும்:' << மற்றும் << endl ;
எக்ஸ் ++;
மற்றும் ++;
}
திரும்ப 0 ;
}
மேலே உள்ள குறியீடு தருக்க மற்றும் தருக்க அல்லது ஆபரேட்டர்கள் இரண்டின் பயன்பாட்டை நிரூபிக்கிறது லூப் போது . நிபந்தனைகளில் ஒன்று உண்மையாக இருக்கும் வரை லூப் தொடர்ந்து இயங்கும்:
பாட்டம் லைன்
தி லூப் போது C++ இல் ஒரு குறிப்பிட்ட நிபந்தனையைப் பொறுத்து ஒரு குறியீட்டின் தொகுதியை மீண்டும் மீண்டும் இயக்க அனுமதிக்கிறது. இது C++ நிரலாக்கத்தின் ஒரு முக்கிய அங்கமாகும், இது குறியீட்டை சுருக்கமாகவும் பராமரிக்கவும் எளிதாக்குகிறது. என்ற தொடரியல் லூப் போது சோதிக்கப்பட வேண்டிய நிபந்தனை, மீண்டும் மீண்டும் செயல்படுத்தப்பட வேண்டிய அறிக்கைகள் மற்றும் முடிவில் அதிகரிப்பு அல்லது குறைப்பு செயல்பாடு ஆகியவை அடங்கும். AND மற்றும் OR போன்ற லாஜிக்கல் ஆபரேட்டர்கள் சிறிது நேர சுழற்சியில் பயன்படுத்தப்படலாம், அதுமட்டுமல்லாமல் எப்போதும் உண்மையாக இருக்கும் ஒரு நிபந்தனையைப் பயன்படுத்துவதன் மூலம் ஒரு எல்லையற்ற வளையத்தையும் உருவாக்க முடியும்.