எடுத்துக்காட்டு 1:
இந்த குறியீட்டில் 'iostream' தலைப்பு கோப்பு சேர்க்கப்பட்டுள்ளது. இந்த தலைப்பு கோப்பில் உள்ளீடு அல்லது வெளியீடு செயல்பாடுகள் அறிவிக்கப்பட்டுள்ளதால், இந்த தலைப்பு கோப்பு C++ இல் பயன்படுத்தப்படுகிறது. இதற்குப் பிறகு, நாம் 'std' பெயர்வெளியை வைத்து பின்னர் 'main()' செயல்பாட்டை செயல்படுத்துகிறோம். 'a' மாறியை முழு எண் தரவு வகையாக துவக்கி, பின்னர் 'for' லூப்பை வைக்கிறோம். இந்த சுழற்சியில், நாம் 'a = 0' ஐ வைக்கிறோம், மேலும் நாம் இங்கே சேர்க்கும் நிபந்தனை 'a <= 9' ஆகும். பின்னர், அதை 'a' மதிப்பில் அதிகரிக்கிறோம். பின்வருவனவற்றில், “a == 5” ஐச் செருகும் “if” நிபந்தனையைப் பயன்படுத்துகிறோம், அதன் பிறகு “continue” அறிக்கையை வைக்கிறோம். 'தொடரவும்' அறிக்கைகள் இந்த லூப்பில் இருந்து '5' இன் மதிப்பைத் தவிர்க்க உதவுகின்றன. பின்னர், நாம் 'cout' ஐச் சேர்த்து, மீதமுள்ள எண்களை அச்சிடுகிறோம். 'தொடரவும்' அறிக்கையைச் சேர்த்ததால், '5' தவிர அனைத்து எண்களையும் இது வழங்குகிறது.
குறியீடு 1:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக அ ;
க்கான ( அ = 0 ; அ <= 9 ; அ ++ ) {
என்றால் ( அ == 5 ) {
தொடரவும் ;
}
கூட் << 'எண்' << அ << endl ;
}
திரும்ப 0 ;
}
வெளியீடு:
இங்கே, அனைத்து எண்களும் வழங்கப்படுகின்றன, ஆனால் இந்த வெளியீட்டில் இருந்து '5' என்ற எண் தவிர்க்கப்பட்டது, மேலும் இந்த லூப்பில் இருந்து '5' என்ற எண்ணைத் தவிர்க்க 'தொடரவும்' அறிக்கையைச் சேர்த்ததால் இங்கு வழங்கப்படவில்லை.
எடுத்துக்காட்டு 2:
'while' லூப்பில் உள்ள 'continue' அறிக்கையைப் பயன்படுத்துகிறோம். குறியீட்டில் 'iostream' தலைப்புக் கோப்பு உள்ளது, ஏனெனில் உள்ளீடு மற்றும் வெளியீட்டு முறைகள் இந்த தலைப்புக் கோப்பில் அறிவிக்கப்பட்டுள்ளன. பின்னர் “std” பெயர்வெளி சேர்க்கப்படும், மேலும் “main()” செயல்பாடு இங்கே அழைக்கப்படுகிறது. இதற்குப் பிறகு, நாம் 'int' ஐ வைத்து, 'num' பெயருடன் ஒரு முழு எண் மாறியை துவக்குகிறோம். இதற்குப் பிறகு, 'while()' லூப்பைப் பயன்படுத்தி, 'num <= 12' நிபந்தனையை வைக்கிறோம்.
இதற்குக் கீழே, 'எண் == 7' என்ற மற்றொரு நிபந்தனையை உள்ளடக்கிய 'if' ஐ வைக்கிறோம். பின்னர், 'எண்++' ஐ வைக்கிறோம், இது 'எண்' மதிப்பில் ஒன்று அதிகரிக்கும். இதற்குப் பிறகு, 'தொடரவும்' அறிக்கையைப் பயன்படுத்துகிறோம். இந்த 'தொடரவும்' அறிக்கையானது 'while' லூப்பில் இருந்து '7' எண்ணைத் தவிர்க்கிறது. 'கவுட்' சேர்க்கப்பட்டு மீதமுள்ள எண்கள் அச்சிடப்படுகின்றன. 'தொடரவும்' அறிக்கையை நாங்கள் செருகியதால், அது '7' தவிர மற்ற எல்லா எண்களையும் வழங்குகிறது. இதற்குப் பிறகு, 'num' இன் மதிப்பை அதிகரிக்க 'num++' ஐ வைக்கிறோம்.
குறியீடு 2:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக ஒன்றில் = 0 ;
போது ( ஒன்றில் <= 12 ) {
என்றால் ( ஒன்றில் == 7 ) {
ஒன்றில் ++;
தொடரவும் ;
}
கூட் << 'வேலை லூப்பைப் பயன்படுத்தி எண்ணைக் காட்டுகிறோம்' << ஒன்றில் << endl ;
ஒன்றில் ++;
}
திரும்ப 0 ;
}
வெளியீடு:
இந்த நிகழ்வில் அனைத்து எண்களும் அச்சிடப்பட்டிருப்பதால், '7' எண்ணைத் தவிர்க்க லூப்பில் 'தொடரவும்' அறிக்கை சேர்க்கப்படுவதால், '7' என்ற எண் வெளியீட்டில் இருந்து தவிர்க்கப்பட்டது.
எடுத்துக்காட்டு 3:
இந்த 'தொடரவும்' அறிக்கையை உள்ளமைக்கப்பட்ட 'for' லூப்பில் சேர்க்கிறோம். தலைப்பு கோப்பு மற்றும் “std” பெயர்வெளியைச் செருகிய பிறகு, “main()” முறையைப் பயன்படுத்துகிறோம். “n1” மற்றும் “n2” மாறிகள் இங்கே முழு எண் வகையாக அறிவிக்கப்படுகின்றன. இப்போது, “n1 <= 4” நிபந்தனையைக் கொண்ட “for” லூப்பைப் பயன்படுத்துகிறோம். இதற்குக் கீழே, மீண்டும் 'for' லூப்பை வைக்கிறோம், அது 'nested for' லூப் ஆகும். இரண்டாவது 'for' லூப்பில் 'n2 <= 4' என்று சொல்லும் நிபந்தனை உள்ளது.
இப்போது, 'if' ஐப் பயன்படுத்துகிறோம், அதில் நிபந்தனையைச் சேர்த்து, '&&' ஆபரேட்டரைப் பயன்படுத்துகிறோம். 'தொடரவும்' பின்னர் இங்கே சேர்க்கப்படும். 'n1' என்பது '3' மற்றும் 'n2' '3' ஆக இருக்கும் மதிப்புகளை மட்டும் இது தவிர்க்கிறது. “n1” மற்றும் “n2” இரண்டும் ”3” ஆக இருக்கும் போது, அது இங்கே லூப்பின் மறு செய்கையைத் தவிர்க்கிறது. பின்னர், மீதமுள்ள மதிப்புகளை வழங்குவதற்கு கீழே உள்ள 'cout' ஐப் பயன்படுத்துகிறோம்.
குறியீடு 3:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக n1 , n2 ;
க்கான ( n1 = 1 ; n1 <= 4 ; n1 ++ ) {
க்கான ( n2 = 1 ; n2 <= 4 ; n2 ++ ) {
என்றால் ( n1 == 3 && n2 == 3 ) {
தொடரவும் ;
}
கூட் << 'n1 =' << n1 << 'n2 =' << n2 << endl ;
}
}
}
வெளியீடு:
இரண்டு மாறி மதிப்புகள் '3' மற்றும் மற்ற எல்லா மதிப்புகளும் இங்கே அச்சிடப்பட்டிருக்கும் மறு செய்கையைத் தவிர்க்க, உள்ளமைக்கப்பட்ட வளையத்தில் 'தொடரவும்' வரி சேர்க்கப்படுவதால்.
எடுத்துக்காட்டு 4:
'num_1' என்ற பெயரிடப்பட்ட 'int' மாறியானது '1' மதிப்புடன் துவக்கப்பட்டது. பின்னர், “while” லூப்பைப் பயன்படுத்தி, “num_1 <= 9” நிபந்தனையைச் சேர்க்கிறோம். இதற்கு கீழே, 'cout' சேர்க்கப்பட்டுள்ளது மற்றும் 'if' நிபந்தனை அங்கு வைக்கப்பட்டுள்ளது. 'if' நிபந்தனையானது, '2' ஆல் வகுக்கும் போது, மீதமுள்ள எண்ணை பூஜ்ஜியத்திற்கு சமமாக சரிபார்க்கிறது. நமது குறியீட்டில் உள்ள இரட்டை எண்ணை சரிபார்க்க விரும்பும் போது இந்த நிபந்தனை சேர்க்கப்படுகிறது. கீழே, “num_1” இன் மதிப்பை அதிகரிக்க “num_1++” ஐ வைக்கிறோம். இங்கே, லூப்பில் இருந்து இரட்டை எண்களைத் தவிர்க்க “தொடரவும்” என்பதைப் பயன்படுத்துகிறோம், மேலும் லூப்பில் இருக்கும் இரட்டை எண்ணுக்கு கொடுக்கப்பட்ட செய்தியை வழங்க வேண்டாம்.
குறியீடு 4:
# அடங்கும்பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக எண்_1 = 1 ;
போது ( எண்_1 <= 9 ) {
கூட் << 'எண் =' << எண்_1 << endl ;
என்றால் ( எண்_1 % 2 == 0 ) {
எண்_1 ++;
தொடரவும் ;
}
கூட் << 'எண்' << எண்_1 << 'இது ஒற்றைப்படை எண்' << endl ;
எண்_1 ++;
}
திரும்ப 0 ;
}
வெளியீடு:
இங்கே, வெளியீட்டில் இருந்து இரட்டை எண்கள் தவிர்க்கப்பட்டிருப்பதையும், ஒற்றைப்படை எண்ணுக்கான செய்தி இங்கே கொடுக்கப்பட்டிருப்பதையும் நாம் நமது குறியீட்டில் செருகிய “தொடரவும்” அறிக்கையின் காரணமாகக் காணலாம்.
எடுத்துக்காட்டு 5:
எங்களின் கடைசிக் குறியீட்டில், “45”க்குக் குறைவான மதிப்புகளைப் பயனரிடமிருந்து பெற்று, எதிர்மறை மதிப்பை உள்ளிட்டு, கொடுக்கப்பட்ட மதிப்புகளின் கூட்டுத்தொகையைக் கணக்கிடும்போது பயனர் உள்ளீட்டை நிறுத்துவோம். முதலில், முழு எண் தரவு வகைகளாக 'சம்மேஷன்' மற்றும் 'மதிப்பு' ஆகியவற்றை துவக்குகிறோம்.
பின்னர், மதிப்பு நேர்மறையா இல்லையா என்பதைச் சரிபார்க்கவும். பின்னர், மதிப்பு நேர்மறையாக இருந்தால், 'சம்மேஷன் + = மதிப்பு' என்பதைப் பயன்படுத்தவும் மற்றும் 'தொகைக்கான எண்ணை உள்ளிடவும்' என்ற செய்தியை வழங்கவும். இதற்குக் கீழே, எண்ணைப் பெறவும், அதை 'மதிப்பில்' சேமிக்கவும் 'சின்' ஐப் பயன்படுத்துகிறோம். இப்போது, நாம் முன்னேறி, 'மதிப்பு > 45' என்பதைப் பார்க்கிறோம். இந்த நிபந்தனை பூர்த்தி செய்யப்பட்டால், '45' க்கும் குறைவான மதிப்பை உள்ளிடுவதற்கு நாம் ஒரு செய்தியை எழுதியுள்ள வரியை இயக்க வேண்டும். பின்னர், “மதிப்பு = 0” ஐ ஒதுக்கி, அந்த மதிப்பைத் தவிர்த்து, பயனரிடமிருந்து புதிய மதிப்பைப் பெறும் தொடர் அறிக்கையை வைக்கவும். இதற்குப் பிறகு, 'சம்மேஷன்' கணக்கிட்டு அதை வழங்குகிறோம். நாம் எதிர்மறை மதிப்பை உள்ளிடும்போது இந்த கூட்டுத்தொகை செய்யப்படுகிறது.
குறியீடு 5:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக கூட்டுத்தொகை = 0 ;
முழு எண்ணாக மதிப்பு = 0 ;
போது ( மதிப்பு >= 0 ) {
கூட்டுத்தொகை += மதிப்பு ;
கூட் << 'தயவுசெய்து தொகைக்கான எண்ணை உள்ளிடவும்:' ;
உண்ணுதல் >> மதிப்பு ;
என்றால் ( மதிப்பு > நான்கு. ஐந்து ) {
கூட் << 'நீங்கள் இங்கே உள்ளிட்ட எண் 45 ஐ விட அதிகமாக உள்ளது, எனவே நாங்கள் அதை கணக்கிட மாட்டோம்' << endl ;
மதிப்பு = 0 ;
தொடரவும் ;
}
}
கூட் << 'உள்ளிட்ட எண்ணின் கூட்டுத்தொகை' << கூட்டுத்தொகை << endl ;
திரும்ப 0 ;
}
வெளியீடு:
இந்த முடிவு, எங்கள் குறியீடு பயனரின் உள்ளீட்டை எவ்வாறு பெறுகிறது, கூட்டுத்தொகையைப் பயன்படுத்துகிறது மற்றும் '45' ஐ விட அதிகமான மதிப்பை உள்ளிடும்போது ஒரு செய்தியைக் காண்பிக்கும். இங்கே, “45” ஐ விட அதிகமான மதிப்புகள் தவிர்க்கப்பட்டு, கூட்டுத்தொகை செயல்பாட்டில் கணக்கிடப்படாமல் இருப்பதை நாம் கவனிக்கலாம். ஏனென்றால், எங்கள் குறியீட்டில் அந்த இடத்தில் “தொடரவும்” அறிக்கையைப் பயன்படுத்தினோம்.
முடிவுரை
C++ நிரலாக்கத்தில் 'தொடரவும்' கருத்து இந்த வழிகாட்டியில் முழுமையாகப் படிக்கப்படுகிறது. இந்த 'தொடரவும்' அறிக்கையானது, வெளியீட்டில் இருந்து விரும்பிய மதிப்பைத் தவிர்ப்பதற்கு எவ்வாறு உதவுகிறது என்பதை நாங்கள் ஆராய்ந்தோம். எங்கள் குறியீடுகளில் இந்த “தொடரவும்” அறிக்கையைப் பயன்படுத்தினோம், மேலும் ஒவ்வொரு குறியீட்டையும் இந்தக் குறியீடுகளின் விளைவுகளையும் விளக்கினோம். 'for', 'while' மற்றும் 'nested for' லூப்பில் இந்த 'continue' அறிக்கையைப் பயன்படுத்தினோம்.