புரோகிராமிங்கில் இருக்கும் போது நீங்கள் எப்படி வளையத்தைப் பயன்படுத்துகிறீர்கள்?

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

நிரலாக்கத்தில் இருக்கும்போது

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

இதன் பொருள் அறிவுறுத்தலின் மதிப்பீடு உண்மையாக இருக்கும்போது மட்டுமே அது மீண்டும் மீண்டும் வருகிறது.

நிரலாக்கத்தில் if அல்லது switch அறிக்கை போன்ற கட்டுப்பாட்டு கட்டமைப்புகளுக்கு கூடுதலாக, மீண்டும் மீண்டும் கட்டமைப்புகள் உள்ளன.

மீண்டும் மீண்டும் வரும் நிரலாக்க கட்டமைப்புகளில், சிறிது வளையத்துடன் தொடர்புடையது, இது ஒரு உண்மையான மதிப்பை கொண்டிருக்கும் வரை குறியீட்டின் ஒரு தொகுதியை மீண்டும் செய்கிறது, இது பின்வருமாறு வெளிப்படுத்தப்படலாம்:

• போது (நிபந்தனை).
• {.
• அறிவுறுத்தல்கள்;
• }.

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

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

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

இது தொடர்பான ஒரு சுவாரஸ்யமான கட்டுரையை இங்கே பரிந்துரைக்கிறோம் சி மொழி.

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

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

ஒரு வேல் லூப் எப்படி வேலை செய்கிறது?

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

உதாரணமாக, சில காரணங்களால், ஒரு பயனர் தங்களுக்கு ஏற்படும் பல எண்களைக் கேட்டார், மேலும் அவர்கள் 100 ஐ விட அதிகமான எண்ணை உள்ளிடுகிறார்கள் என்று நாங்கள் நினைக்கிறோம்.

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

எனவே, பயனர் தொடர்ந்து பின்வரும் எண்களை உள்ளிட்டால்: 1, 50, 99, 49, 21, 30, 100, நிரல் முடிவடையாது, ஏனென்றால் எண்கள் 100 ஐ விட அதிகமாக இல்லை, ஆனால், எண்ணை உள்ளிடும் வழக்கில் 300, திட்டம் உடனடியாக முடிவடையும் என்ற நிபந்தனை உள்ளது.

சி ++ இல் லூப் தொடரியல்

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

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

பின்வரும் உதாரணத்தில் ஒரு இறுதி நிலை எப்படி வைக்கப்படும் என்று பார்ப்போம்:

• அதே நேரத்தில் (இறுதி நிலை) // உதாரணமாக எண் == 100.
• {.
• ....
• ....
• ....
• ....
• }.

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

வரி 1: அதன் உள்ளடக்கத்தில் சிறிது நேர வளையத்தில் மிக முக்கியமானது.

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

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

பதிவுசெய்யப்பட்ட நிபந்தனை எப்போதும் பூலியன் மதிப்பை எடுக்கும் என்பது தெளிவாக உள்ளது, அதாவது உண்மை அல்லது பொய்.

வரி 2: இந்த வரியில் ஒரு "{" திறப்பு தோன்றுகிறது, அதாவது இந்த பகுதியில் ஒரு கட்டளை அறிவுறுத்தல்கள் தொடங்கப்படுகின்றன, இது சுழற்சி தொடங்கியவுடன் நிறைவேற்றப்படும்.

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

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

வரி 8: இது கடைசி வரியாகும் மற்றும் விசையை "}" மூடுவதன் மூலம் பயன்படுத்த வேண்டும்.

C ++ இல் உள்ள சுழல்களின் பயன்பாட்டை பயனர்கள் தெளிவான மற்றும் எளிமையான வழியில் புரிந்துகொள்ள வழிவகுக்கும் சில எடுத்துக்காட்டுகளை இப்போது காண்பிப்போம், நாங்கள் தொடங்குகிறோம்:

எடுத்துக்காட்டு 1: 100 ஐ விட அதிகமாக இருக்கும் வரை திரையில் எண்களைக் கேட்கவும்

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

தீர்வு உதாரணம் 1:

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

இது பின்வரும் வழியில் பிரதிபலிக்கப்படுவதைக் காணலாம்:

• முழு எண்;.
• சின் >> எண்;.
• போது (எண் <= 100).
• {.
• cout << «தயவுசெய்து ஒரு எண்ணை உள்ளிடவும்« ;.
• சின் >> எண்;.
• }.

முழுமையான செயல்பாட்டு குறியீடு பயனரால் கையாள மிகவும் எளிதானது, அதை எவ்வாறு பயன்படுத்துவது என்பது கீழே கொடுக்கப்பட்டுள்ளது:

• #"ஐஓஸ்ட்ரீம்" அடங்கும்.
• நேம்ஸ்பேஸ் std ஐப் பயன்படுத்துதல்;
• int முக்கிய ().
• {.
•  முழு எண்;.
•  cout << «தயவுசெய்து ஒரு எண்ணை உள்ளிடவும்« ;.
•  சின் >> எண்;.
•  போது (எண் <= 100).
•  {.
•  cout << «தயவுசெய்து ஒரு எண்ணை உள்ளிடவும்« ;.
•  சின் >> எண்;.
•  }.
•  அமைப்பு ("இடைநிறுத்தம்");
•  திரும்ப 0;.
• }.

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