எடுத்துக்காட்டு 1:
'iostream' இங்கே சேர்க்கப்பட்டுள்ளது, பல செயல்பாடுகள் அறிவிக்கப்பட்ட தலைப்பு கோப்பு. இந்த தலைப்புக் கோப்பில் அறிவிக்கப்பட்டுள்ள இந்த செயல்பாடுகளை எங்கள் குறியீட்டில் பயன்படுத்துகிறோம், எனவே இந்த தலைப்புக் கோப்பைச் சேர்க்கிறோம். இதற்குப் பிறகு, 'சின்' மற்றும் 'கவுட்' போன்ற செயல்பாடுகளும் இதில் வரையறுக்கப்பட்டுள்ளதால், 'std' இங்கே வைக்கப்பட்டுள்ளது. நமது குறியீட்டின் தொடக்கத்தில் 'namespace std'ஐச் சேர்த்தால், இந்த எல்லா செயல்பாடுகளிலும் 'std' என்று தட்டச்சு செய்ய வேண்டியதில்லை. இதற்குப் பிறகு, 'முதன்மை()' செயல்பாடு இங்கே செயல்படுத்தப்படுகிறது, இது C++ நிரலின் இயக்கி குறியீடு என்றும் குறிப்பிடப்படுகிறது.
பின்னர், 'முயற்சி' முக்கிய சொல்லைப் பயன்படுத்துகிறோம், அதில் '35' மதிப்புடன் 'my_num1' ஐ துவக்குகிறோம். இது இங்கே 'int' தரவு வகை மாறி. இப்போது, இந்த மாறியை “if” க்குள் வைத்து, “my_num1” “98” ஐ விட அதிகமாகவோ அல்லது அதற்கு சமமாகவோ இருக்க வேண்டும் என்று ஒரு நிபந்தனையை வைக்கிறோம். கொடுக்கப்பட்ட நிபந்தனை திருப்தி அடைந்தால், அது 'if' இன் உள்ளே நகர்ந்து இங்கே எழுதப்பட்ட அறிக்கையை செயல்படுத்துகிறது. நாங்கள் 'கவுட்' ஐப் பயன்படுத்துகிறோம் மற்றும் நிபந்தனை திருப்திகரமாக இருக்கும்போது காண்பிக்க ஒரு செய்தியைச் செருகுவோம்.
இதற்குப் பிறகு, 'else' ஐ வைத்த பிறகு 'த்ரோ' முக்கிய சொல்லைப் பயன்படுத்துகிறோம். இந்த 'த்ரோ' முக்கிய வார்த்தையில், 'my_num1' ஐ அளவுருவாக அனுப்புகிறோம். இதற்குக் கீழே 'பிடிப்பு' பகுதியைச் சேர்க்கிறோம். “catch()” இன் அளவுருவாக “my_num2” ஐச் செருகி, இந்த “catch” பகுதிக்குள் மீண்டும் “cout” ஐப் பயன்படுத்துவோம். 'முயற்சி' பகுதியில் விதிவிலக்கு ஏற்படும் போது மட்டுமே இந்த பகுதி இயங்கும்.
குறியீடு 1:
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( ) {
முயற்சி {
முழு எண்ணாக என்_எண்1 = 35 ;
என்றால் ( என்_எண்1 >= 98 ) {
கூட் << 'அணுகல் இங்கே வழங்கப்படுகிறது.' ;
} வேறு {
வீசு ( என்_எண்1 ) ;
}
}
பிடி ( முழு எண்ணாக என்_எண்2 ) {
கூட் << 'அணுகல் இங்கே மறுக்கப்பட்டது.' << endl ;
கூட் << 'எண்:' << என்_எண்2 ;
}
திரும்ப 0 ;
}
வெளியீடு:
நாங்கள் உள்ளிட்ட எண் '35' ஆகும், இது '98' ஐ விடக் குறைவு. எனவே, விதிவிலக்கு அங்கு நிகழ்கிறது மற்றும் 'கேட்ச் ()' பகுதி காட்டப்படும். 'முயற்சி' பகுதிக்கான அணுகல் மறுக்கப்பட்டது.
எடுத்துக்காட்டு 2:
இங்கே 'iostream' தலைப்புக் கோப்பையும் 'namespace std'ஐயும் வைக்கிறோம். இதற்குப் பிறகு, 'பிரிவு()' செயல்பாட்டை உருவாக்குகிறோம், அதில் 'int' தரவு வகையின் 'நியூமரேட்டர்' மற்றும் 'டினாமினேட்டர்' ஆகிய இரண்டு அளவுருக்களை வைக்கிறோம். இந்த 'பிரிவு' செயல்பாட்டின் தரவு வகையை 'இரட்டை' என அமைத்துள்ளோம்.
இதற்குக் கீழே, “if()” ஐச் சேர்க்கிறோம், அதில் வகுத்தல் பூஜ்ஜியத்திற்கு சமம் என்ற நிபந்தனையைச் சேர்க்கிறோம். இதற்குப் பிறகு, நாங்கள் 'எறி' முக்கிய சொல்லைப் பயன்படுத்துகிறோம் மற்றும் அங்கு ஒரு செய்தியைத் தட்டச்சு செய்கிறோம். நிபந்தனைக்கு ஏற்ப இந்த குறியீட்டில் விதிவிலக்கு ஏற்படும் போதெல்லாம் இந்த செய்தி ரெண்டர் செய்யப்படும். இதற்குக் கீழே, 'ரிட்டர்ன்' முக்கிய சொல்லைப் பயன்படுத்துகிறோம், அதில் 'நியூமரேட்டர்/டினாமினேட்டரை' வைக்கிறோம். எனவே, அது பிரிவின் முடிவைத் தருகிறது. இப்போது, 'முக்கிய()' செயல்பாடு அழைக்கப்படுகிறது.
இதற்குப் பிறகு, 'num1' மற்றும் 'num2' ஆகியவை 'int' மாறிகளாக துவக்கப்பட்டு, அவற்றுக்கு முறையே '89' மற்றும் '0' ஐ ஒதுக்குகின்றன. பின்னர், 'இரட்டை' தரவு வகையின் 'முடிவை' துவக்குகிறோம். இங்கே, 'முயற்சி' முக்கிய சொல்லைப் பயன்படுத்துகிறோம். இந்த பகுதியில், இந்த “முடிவு” மாறியைச் சேர்த்து, இந்த மாறிக்கு “டிவிஷன்()” செயல்பாட்டை ஒதுக்குகிறோம். இந்த செயல்பாட்டிற்கு இரண்டு அளவுருக்களை அனுப்புகிறோம்: 'num1' மற்றும் 'num2'. இதற்குக் கீழே, 'டிவிஷன்()' செயல்பாட்டைப் பயன்படுத்திய பிறகு நாம் பெறும் 'முடிவை' காண்பிக்கிறோம். இதற்குப் பிறகு, நாங்கள் 'கேட்ச்' ஐப் பயன்படுத்தி, நாங்கள் முன்பு சேர்த்த செய்தியைக் காட்ட 'const char* msg' ஐ வைக்கிறோம்.
குறியீடு 2:
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
இரட்டை பிரிவு ( முழு எண்ணாக எண், முழு எண்ணாக வகுக்கும் ) {
என்றால் ( வகுக்கும் == 0 ) {
வீசு 'பூஜ்ஜியத்தால் வகுத்தல் இங்கு சாத்தியமில்லை!' ;
}
திரும்ப ( எண் / வகுக்கும் ) ;
}
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக எண்1 = 89 ;
முழு எண்ணாக எண்2 = 0 ;
இரட்டை விளைவாக = 0 ;
முயற்சி {
விளைவாக = பிரிவு ( எண்1, எண்2 ) ;
கூட் << விளைவாக << endl ;
} பிடி ( நிலையான கரி * செய்தி ) {
செர்ர் << செய்தி << endl ;
}
திரும்ப 0 ;
}
வெளியீடு:
நாங்கள் முன்பு வகுப்பாகச் செருகிய எண் “0”. எனவே, விதிவிலக்கு குறியீட்டில் ஏற்படுகிறது மற்றும் அது கொடுக்கப்பட்ட செய்தியைக் காட்டுகிறது.
எடுத்துக்காட்டு 3:
'பெருக்கல்()' செயல்பாடு இங்கு உருவாக்கப்பட்டுள்ளது, இதில் 'மதிப்பு' மற்றும் 'பெருக்கி' ஆகியவற்றை 'int' தரவு வகையின் அளவுருக்களாக வைக்கிறோம். பின்னர், 'if' ஐப் பயன்படுத்துகிறோம், அதில் பூஜ்ஜியத்திற்கு சமமான பெருக்கி நிபந்தனையைச் சேர்க்கிறோம். பின்னர், நாம் ஒரு அறிக்கையைச் சேர்க்கும் இடத்தில் 'எறி' வைக்கப்படுகிறது. பின்னர், நாம் முன்பு அறிவித்த 'மதிப்பு * பெருக்கி' மாறிகளை வைக்கும் 'திரும்ப' உள்ளது. எனவே, இது பெருக்கல் முடிவை இங்கே தருகிறது.
இதற்குப் பிறகு, 'முக்கிய()' என்று அழைக்கிறோம், அங்கு முறையே '34' மற்றும் '0' மதிப்புகளுடன் 'int value1' மற்றும் 'int value2' ஐ அறிவிக்கிறோம். 'int m_res' என்பதும் அறிவிக்கப்பட்டு பின்னர் இங்கு 'பெருக்கல்()' செயல்பாடு என்று அழைக்கப்படுகிறது. இந்தச் செயல்பாட்டைச் செய்த பிறகு, முடிவு இப்போது “m_res” மாறியில் சேமிக்கப்பட்டு பின்னர் காட்டப்படும். அதைத் தொடர்ந்து, 'பிடிப்பு' செயல்பாட்டைப் பயன்படுத்துகிறோம் மற்றும் 'எறிதல்' பகுதியில் நாங்கள் முன்பு சேர்த்த செய்தியைக் காண்பிக்க 'const char* msg' ஐச் செருகுவோம்.
குறியீடு 3:
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
இரட்டை பெருக்கல் ( முழு எண்ணாக மதிப்பு , முழு எண்ணாக பெருக்கி ) {
என்றால் ( பெருக்கி == 0 ) {
வீசு 'நாங்கள் மதிப்பை பூஜ்ஜியத்துடன் பெருக்குவதில்லை!' ;
}
திரும்ப ( மதிப்பு * பெருக்கி ) ;
}
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக மதிப்பு1 = 3. 4 ;
முழு எண்ணாக மதிப்பு2 = 0 ;
முழு எண்ணாக m_res ;
முயற்சி {
m_res = பெருக்கல் ( மதிப்பு1, மதிப்பு2 ) ;
கூட் << m_res << endl ;
} பிடி ( நிலையான கரி * செய்தி ) {
செர்ர் << செய்தி << endl ;
}
திரும்ப 0 ;
}
வெளியீடு :
நாம் முன்பு உள்ளிட்ட மதிப்பானது பெருக்கியாக “0” இருப்பதால், குறியீட்டிற்கு விதிவிலக்கு உள்ளது, இது அறிவிப்பு இங்கே காட்டப்படும்.
எடுத்துக்காட்டு 4:
இங்கே, நாம் “பெருக்கி()” செயல்பாட்டை உருவாக்கி, “int” தரவு வகையின் அளவுருக்களாக “number1” மற்றும் “number2” ஐ அனுப்புகிறோம். அடுத்து, பூஜ்ஜியத்தை விட குறைவான அல்லது அதற்கு சமமான பெருக்கியான நிபந்தனையைச் சேர்க்க “if” ஆபரேட்டரைப் பயன்படுத்துகிறோம். அதன் பிறகு, 'எறிதல்' இருக்க வேண்டிய இடத்தில் அறிக்கை சேர்க்கப்படுகிறது. பெருக்கல் முடிவு 'திரும்ப' பிரிவில் திரும்பும், அங்கு நாம் முன்பு அறிவித்த 'எண்1 * எண்2' மாறியைச் செருகுவோம்.
அதன் பிறகு, 'முக்கிய()' செயல்பாட்டை செயல்படுத்தி, '34' மற்றும் '12' மதிப்புகளை முறையே 'int newNumber1' மற்றும் 'int newNumber2' க்கு ஒதுக்குவோம். இங்கே, 'multiply()'செயல்பாடு 'int mResult' அறிவிப்புக்குப் பிறகு அழைக்கப்படுகிறது. இப்போது, இந்த செயல்பாட்டின் விளைவு 'mResult' மாறியில் சேமிக்கப்பட்டு, பின்வருவனவற்றில் வழங்கப்படுகிறது. 'பிடிப்பு' செயல்பாட்டைப் பயன்படுத்தி, 'எறிதல்' பிரிவில் நாம் எழுதிய செய்தியைக் காண்பிக்க 'const char* msg' ஐச் சேர்ப்போம்.
குறியீடு 4:
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
இரட்டை பெருக்கி ( முழு எண்ணாக இலக்கம் 1 , முழு எண்ணாக எண்2 ) {
என்றால் ( எண்2 <= 0 ) {
வீசு 'நாங்கள் மதிப்பை பூஜ்ஜியம் அல்லது எதிர்மறை மதிப்புடன் பெருக்குவதில்லை!' ;
}
திரும்ப ( இலக்கம் 1 * எண்2 ) ;
}
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக புதிய எண்1 = 3. 4 ;
முழு எண்ணாக புதிய எண்2 = 12 ;
முழு எண்ணாக mResult ;
முயற்சி {
mResult = பெருக்கி ( newNum1, newNum2 ) ;
கூட் << 'பெருக்கத்தின் விளைவு' << mResult << endl ;
}
பிடி ( நிலையான கரி * செய்தி ) {
செர்ர் << செய்தி << endl ;
}
திரும்ப 0 ;
}
வெளியீடு:
நாம் சேர்க்கும் மதிப்பு “12”, அதில் நிபந்தனையைச் சேர்க்கிறோம். எனவே, நிபந்தனை உண்மையில்லாததால் 'பெருக்கி()' செயல்பாடு செய்யப்படுகிறது. பெருக்கத்தின் முடிவு காட்டப்படும். 'முயற்சி' பகுதி இங்கே செயல்படுத்தப்படுகிறது.
முடிவுரை
இந்த வழிகாட்டியில் உள்ள 'ட்ரை-கேட்ச்' கருத்து மற்றும் குறியீடுகள் விரிவாக ஆய்வு செய்யப்படுகின்றன. இந்த 'ட்ரை-கேட்ச்' கான்செப்ட்டை நாங்கள் முழுமையாக ஆராய்ந்து, C++ புரோகிராமிங்கில் இது எவ்வாறு செயல்படுகிறது என்பதைக் காட்டினோம். எங்களின் தனித்துவமான குறியீட்டை எழுத உதவும் பிழை கண்டறியப்பட்டால் 'எறி' என்ற சொல் விதிவிலக்கை உருவாக்குகிறது என்று நாங்கள் வரையறுத்துள்ளோம். 'பிடி' வெளிப்பாட்டைப் பயன்படுத்தி, 'முயற்சி' பகுதியில் விதிவிலக்கு தோன்றினால், இயக்க வேண்டிய குறியீட்டின் தொகுதியைக் குறிப்பிடலாம்.