சி++ இல் உள்ள டெர்னரி ஆபரேட்டரின் தொடரியல்
மும்முனை ஆபரேட்டருக்கு மூன்று செயல்பாடுகள் தேவை: நிபந்தனை, உண்மை மற்றும் தவறானது. டெர்னரி ஆபரேட்டர் சோதனை நிலையை பகுப்பாய்வு செய்து, முடிவைப் பொறுத்து, குறியீட்டின் தொகுதியை இயக்கும்போது, தொடரியல்:
# (exp_1) ? exp_2 : exp_3இங்கே 'exp' என்பது வெளிப்பாட்டைக் குறிக்கிறது. வெளிப்பாட்டின் முடிவைப் பொறுத்து, இந்த ஆபரேட்டர் இரண்டு மதிப்புகளில் ஒன்றை வழங்குகிறது. வெளிப்பாடுகள் 2 மற்றும் 3 மதிப்பீடு செய்யப்படுகிறது, மேலும் 'exp_1' பூலியன் உண்மையாக மதிப்பிடப்பட்டால் அவற்றின் மதிப்புகள் இறுதி முடிவுகளாக வழங்கப்படும்; மற்றபடி, வெளிப்பாடு 1 ஆனது பூலியன் தவறானதாக மதிப்பிடப்படுகிறது, மேலும் வெளிப்பாடு 2 மதிப்பிடப்படுகிறது, மேலும் அதன் மதிப்பு இறுதி முடிவாக வழங்கப்படும்.
உதாரணம் 1
C++ இன் டெர்னரி ஆபரேட்டரை எவ்வாறு பயன்படுத்துவது என்பதைக் காட்டும் நேரடியான எடுத்துக்காட்டு நிரல் இங்கே உள்ளது.
#
#
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
இரட்டை CGPA ;
கூட் <> CGPA ;
சரம் மாணவர்_முடிவு = ( CGPA >= 1.5 ) ? 'கடந்துவிட்டது' : 'தோல்வி' ;
கூட் << 'நீ' << மாணவர்_முடிவு << 'செமஸ்டர்.' ;
திரும்ப 0 ;
}
நிரலில், எங்கள் தலைப்புப் பகுதியை C++ நூலகங்களுடன் நிரப்பியுள்ளோம். அதன் பிறகு, 'பயன்படுத்துதல்' என்ற முக்கிய வார்த்தையுடன் பெயர்வெளி std ஐச் சேர்த்தோம். பின்னர், 'இரட்டை' தரவு வகையுடன் 'CGPA' மாறி அதன் உள்ளே அறிவிக்கப்பட்டுள்ளது. அடுத்த வரியில், cout கட்டளையை அச்சிட்டு CGPA ஐ உள்ளிடுமாறு பயனரைக் கேட்டுள்ளோம். சின் கட்டளையுடன், பயனர்கள் CGPA ஐ சேர்க்கிறார்கள்.
பின்னர், 'student_result' என்ற மற்றொரு மாறியை உருவாக்கினோம், அதில் மும்முனை ஆபரேட்டர் உள்ளது. மும்முனை ஆபரேட்டருக்கு இங்கே மூன்று வெளிப்பாடுகள் தேவை. முதலாவதாக, பயனரால் உள்ளிடப்பட்ட CGPA ஆனது '1.5' ஐ விட அதிகமாக உள்ளதா அல்லது சமமாக உள்ளதா என்பதைச் சரிபார்க்கும் நிபந்தனையாகும். அப்படியானால், 'கடந்துவிட்டது' என்ற அறிக்கை அச்சிடப்படும், இல்லையெனில் மூன்றாவது வெளிப்பாடு அச்சிடப்படும். நீங்கள் cout கட்டளையைப் பயன்படுத்தும் போது விளைவு காண்பிக்கப்படும்.
பயனர் CGPA '3.5' ஐ தட்டச்சு செய்கிறார் என்று வைத்துக்கொள்வோம். CGPA >= 1.5 பின்னர் உண்மைக்கு மதிப்பிட்டு, அளவுகோலைப் பூர்த்தி செய்கிறது. எனவே, முடிவு முதல் கால 'கடந்த' வழங்கப்படுகிறது.
பயனர் வகை 1.00 என்று வைத்துக்கொள்வோம். இதன் விளைவாக, CGPA >= 1.5 என்ற நிபந்தனை தவறாக மதிப்பிடப்படுகிறது. எனவே, விளைவு 'தோல்வியுற்றது' என்ற இரண்டாவது வெளிப்பாடு வழங்கப்படுகிறது.
எடுத்துக்காட்டு 2
சில வகையான if else அறிக்கைகள் C++ இல் மும்மை ஆபரேட்டருடன் மாற்றப்படலாம். இந்த குறியீட்டை உதாரணமாக மாற்றலாம். முதல் எடுத்துக்காட்டு நிரல் if-else நிபந்தனையைப் பயன்படுத்துகிறது, மற்ற எடுத்துக்காட்டு நிரல் மும்மை ஆபரேட்டரைப் பயன்படுத்துகிறது.
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக ஒன்றில் = - 3 ;
கூட் << 'ஒன்றில்:' < 0 )
கூட் << ' \n நேர்மறை முழு எண்' ;
வேறு
கூட் << ' \n எதிர்மறை முழு எண்!' ;
திரும்ப 0 ;
}
எதிர்மறை முழு எண் மதிப்புடன் 'num' என்ற int தரவு வகை மாறியை அறிவித்து துவக்கியுள்ளோம். அதன் பிறகு, cout கட்டளையுடன், 'num' மதிப்பு அச்சிடப்படுகிறது. பிறகு, நமக்கு if-else நிபந்தனை உள்ளது. 'if' நிபந்தனையின் உள்ளே, 'எண்' மாறி மதிப்பு பூஜ்ஜியத்தை விட அதிகமாக இருக்க வேண்டும் என்ற நிபந்தனையை நாங்கள் குறிப்பிட்டுள்ளோம். நிபந்தனை உண்மையாகிவிட்டால், 'if' நிபந்தனைக்குப் பிறகு cout கட்டளை அச்சிடப்படும். நிபந்தனை தவறானதாக இருந்தால், மற்ற கவுட் அறிக்கை அச்சிடப்படும்.
எண் எதிர்மறை மதிப்பாக இருப்பதால், if நிபந்தனை தவறானது மற்றும் தி
அடுத்து, மும்மை ஆபரேட்டருடன் மேலே உள்ள நிரலை செயல்படுத்தினோம். if-else நிபந்தனையும் மும்முனை ஆபரேட்டரும் ஒரே மாதிரியான விளைவுகளைக் கொண்டிருக்கிறதா என்பதைப் பார்க்கவும்.
##
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக MyNum = - 7 ;
கூட் << 'முழு:' << MyNum < 0 ) ? 'நேர்மறை முழு எண்!' : 'எதிர்மறை முழு எண்!' ;
கூட் << விளைவு << endl ;
திரும்ப 0 ;
}
'MyNum' என்ற மாறியை அறிவித்து எதிர்மறை மதிப்புடன் துவக்கியுள்ளோம். cout கட்டளையின் உள்ளே 'MyNum' மாறியை அழைத்து எதிர்மறை மதிப்பை அச்சிட்டுள்ளோம். பின்னர், சரம் வகையுடன் மற்றொரு மாறியை 'விளைவு' என அமைக்கிறோம். விளைவு மாறி மும்மை ஆபரேட்டர் செயல்பாட்டை எடுக்கும். முதலில், 'MyNum' பூஜ்ஜியத்தை விட அதிகமாக இருக்க வேண்டும் என்ற நிபந்தனை எங்களிடம் உள்ளது. அதன் பிறகு, நாங்கள் ஒரு மும்முனை ஆபரேட்டரை '?' வைக்கிறோம். நிபந்தனையின் முடிவில் மற்ற இரண்டு வெளிப்பாடுகள் செயல்படுத்தப்படும்.
முழு எண் மதிப்பு '-7' ஆக இருப்பதால் மூன்றாவது வெளிப்பாடு, 'எதிர்மறை முழு எண்!' வரியில் அச்சிடப்பட்டுள்ளது. இங்கே, இரண்டு பயன்பாடுகளிலிருந்தும் வெளியீடு ஒன்றுதான். எவ்வாறாயினும், மும்முனை ஆபரேட்டர் எங்கள் குறியீட்டின் வாசிப்புத்திறனையும் தூய்மையையும் மேம்படுத்துகிறது.
எடுத்துக்காட்டு 3
கூடுதலாக, மும்முனை ஆபரேட்டர்கள் ஒருவரையொருவர் பணியமர்த்தலாம். பின்வரும் திட்டத்தில் ஒரு மதிப்பு நேர்மறையா, எதிர்மறையா அல்லது பூஜ்ஜியமா என்பதைச் சரிபார்க்க, உள்ளமைக்கப்பட்ட மும்மை ஆபரேட்டரைப் பயன்படுத்தவும்.
##
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக முழு = 0 ;
சரம் முடிவு ;
விளைவாக = ( முழு == 0 ) ? 'பூஜ்யம்' : ( ( முழு > 0 ) ? 'நேர்மறை' : 'எதிர்மறை' ) ;
கூட் << 'முழு எண்' << விளைவாக ;
திரும்ப 0 ;
}
நிரலின் முக்கிய முறையுடன் தொடங்கவும். int main() இல், 'integer' என்ற பெயரில் மாறியை உருவாக்கி அதன் மதிப்பை பூஜ்ஜியமாக அமைத்துள்ளோம். பின்னர், தரவு வகை சரத்துடன் 'முடிவு' என்ற மற்றொரு மாறியை வரையறுத்தோம். மும்முனை ஆபரேட்டரைத் தவிர்த்து 'முடிவு' என்ற மாறியை அமைத்துள்ளோம். நிபந்தனை என்னவென்றால், மாறி “முழு எண்” மதிப்பு பூஜ்ஜிய “முழு == 0” க்கு சமமாக இருக்க வேண்டும். ஆரம்ப நிலை, (முழு == 0), கொடுக்கப்பட்ட முழு எண் பூஜ்ஜியமா இல்லையா என்பதை தீர்மானிக்கிறது. அப்படியானால், முடிவு சர மதிப்பு 'பூஜ்யம்' வழங்கப்படுகிறது. பதில் சரியாக இருந்தால். இல்லையெனில், முதல் நிபந்தனை தவறானதாக இருந்தால், இரண்டாவது நிபந்தனை (முழு எண் > 0) ஆராயப்படும்.
ஆம், ஸ்கிரிப்ட்டில் காட்டப்பட்டுள்ளபடி, வழங்கப்பட்ட முழு எண் பூஜ்ஜியமாகும். வெளியீடு 'முழு எண் பூஜ்ஜியம்' ஐ உருவாக்குகிறது.
முடிவுரை
நிபந்தனை ஆபரேட்டர் மும்மை ஆபரேட்டர் என்பதை நாங்கள் அறிவோம். இந்த ஆபரேட்டரின் உதவியுடன், ஒரு நிபந்தனையை சரிபார்த்து, அதற்கு ஏற்ப செயல்படலாம். டெர்னரி ஆபரேட்டருக்குப் பதிலாக if-else நிபந்தனைகளைப் பயன்படுத்தி நாம் அதையே நிறைவேற்றலாம். இந்த C++ டுடோரியல், அதன் தொடரியல் மற்றும் எடுத்துக்காட்டு நிரல்களின் மூலம் டெர்னரி ஆபரேட்டரை எவ்வாறு பயன்படுத்துவது என்பதைக் கற்றுக் கொடுத்தது. இறுதி அறிக்கை சுருக்கமாக இருந்தால் மட்டுமே மும்முனை ஆபரேட்டர் பயன்படுத்தப்பட வேண்டும் என்பதை நினைவில் கொள்ளவும்.