எடுத்துக்காட்டு 1:
இப்போது, இந்த 'பூலியன் தரவு வகையை' நாம் பயன்படுத்தும் சில உதாரணங்களைச் செய்து, அது C++ இல் வேலை செய்கிறது என்பதைக் காட்டுவோம். நமக்குத் தேவையான தலைப்புக் கோப்புகளைச் சேர்ப்பதன் மூலம் எங்கள் குறியீட்டைத் தொடங்குகிறோம். இங்கே நாம் சேர்க்கும் முதல் தலைப்புக் கோப்பு “
இதற்குப் பிறகு, எங்களிடம் ஒரு இயக்கி குறியீடு உள்ளது, அதாவது “முதன்மை()” செயல்பாட்டை இங்கே சேர்க்கிறோம். இப்போது, பூலியன் தரவு வகை 'bool' உடன் 'isBulbOn' மாறியை அறிவித்து, 'உண்மை' என்பதை இங்கே சரிசெய்கிறோம். இதற்குக் கீழே, 'isBulbOff' என்ற மற்றொரு பூலியன் மாறி உள்ளது, அதில் 'false' ஐச் சேர்க்கிறோம். இந்த உண்மை மற்றும் தவறான முடிவு முறையே '1' மற்றும் '0' ஆகும்.
இந்த பூலியன் மதிப்புகளின் வெளியீட்டைச் சரிபார்க்க, 'cout' அறிக்கையைப் பயன்படுத்தி அவற்றை அச்சிடுவோம். இந்த 'கவுட்' அறிக்கையில், முதலில் 'isBulbOn' முடிவை அச்சிடுகிறோம். பின்னர், அடுத்த வரியில், 'isBulbOff' மாறியின் முடிவை அச்சிடுகிறோம். 'endl' இங்கே பயன்படுத்தப்படுகிறது, எனவே இது எங்கள் சுட்டியை அடுத்த வரிக்கு நகர்த்துகிறது.
குறியீடு 1:
#
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( )
{
bool isBulbOn = உண்மை ;
bool isBulbOff = பொய் ;
கூட் << 'இங்கே பல்பு எரிகிறது' << பல்ப்ஆன் << endl ;
கூட் << 'இங்கே பல்ப் எரியவில்லை' << பல்ப்ஆஃப் ;
}
வெளியீடு:
இந்தக் குறியீட்டின் வெளியீடு, பின்வருவனவற்றில் காட்டப்பட்டுள்ளபடி '0' மற்றும் '1' வடிவங்களில் முடிவைக் குறிக்கிறது. இங்கே, '1' என்பது 'உண்மை' முடிவைக் குறிக்கிறது, '0' என்பது 'தவறான' முடிவைக் குறிக்கிறது. 'பூல்' தரவு வகையின் காரணமாக இந்த முடிவைப் பெறுகிறோம்.
எடுத்துக்காட்டு 2:
இப்போது, இந்தக் குறியீட்டின் தொடக்கத்தில் தலைப்புக் கோப்பைச் சேர்த்த பிறகு, பிரதான உள்ளே உள்ள 'பூல்' தரவு வகையின் 'பாஸ்' மற்றும் 'ஃபெயில்' ஆகிய இரண்டு மாறிகளை அறிவிக்கிறோம். இங்கு 'Pass' மாறி 'true' என்றும், 'Fail' மாறி 'false' என்றும் ஒதுக்கப்பட்டுள்ளது. இப்போது, 'Pass' ஆனது '1' ஐ வழங்குகிறது மற்றும் 'Fail' என்பது '0' ஐ வழங்குகிறது.
இப்போது, '1' மற்றும் '0' வடிவத்தில் உண்மை அல்லது தவறான முடிவைப் பெற, எங்கள் 'cout' அறிக்கையில் இந்த bool மாறிகளைப் பயன்படுத்துகிறோம். நாம் 'பாஸ்' போடும் 'கவுட்' என்பது '1' என்று திரும்பும். “Fail” என்பதை நாம் பயன்படுத்தும் இடத்தில் “0” கிடைக்கும். இங்கே, நாம் ஐந்து 'கவுட்' அறிக்கைகளைச் சேர்க்கிறோம், ஒவ்வொன்றும் பூலியன் மாறியைக் கொண்டுள்ளது.
குறியீடு 2:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( )
{
bool பாஸ் = உண்மை ;
bool தோல்வி = பொய் ;
கூட் << 'சதவீதம் 60' << பாஸ் << endl ;
கூட் << 'சதவீதம் 45' << தோல்வி << endl ;
கூட் << 'சதவீதம் 90' << பாஸ் << endl ;
கூட் << 'சதவீதம் 85' << பாஸ் << endl ;
கூட் << 'சதவீதம் 33' << தோல்வி << endl ;
}
வெளியீடு:
இந்த வெளியீட்டில், '1' என்பது 'உண்மையான' முடிவைக் குறிக்கிறது, இது 'பாஸ்' மற்றும் '0' என்பது இந்த வழக்கில் 'தோல்வி' என்ற 'தவறான' முடிவைக் குறிக்கிறது.
எடுத்துக்காட்டு 3:
இந்தக் குறியீட்டில், முறையே “45”, “62” மற்றும் “3” மதிப்புடன் “num_01”, “num_02” மற்றும் “a” ஆகிய மூன்று முழு எண் மாறிகளை துவக்குகிறோம். இதற்குப் பிறகு, 'b_01', 'b_02' மற்றும் 'b_03' ஆகிய மூன்று மாறிகளை நாங்கள் அறிவிக்கிறோம் - மேலும் இவை பூலியன் தரவு வகை 'பூல்' ஆகும். இப்போது, “b_01” ஐ “num_01 == num_01” நிபந்தனையுடன் துவக்குகிறோம். பின்னர், 'b_01' போலவே 'b_02' மற்றும் 'b_03' ஐ துவக்குகிறோம்.
அனைத்து மாறிகளையும் துவக்கிய பிறகு, இந்த பூலியன் மாறிகளின் முடிவைச் சரிபார்க்க 'cout' ஐப் பயன்படுத்தி தனித்தனியாக அச்சிடுவோம். இதற்குப் பிறகு, 'பூல்' தரவு வகையின் 'b_a' மாறியை 'true' உடன் துவக்குவோம். பின்னர், 'b_a' ஐ நிபந்தனையாக வைக்கும் இடத்தில் 'if' அறிக்கையைப் பயன்படுத்துகிறோம். இப்போது, இந்த 'b_a' நிபந்தனை உண்மையாக இருந்தால், 'if' க்குப் பின் வரும் அறிக்கை செயல்படுத்தப்படும். இல்லையெனில், 'வேறு' பகுதி இங்கே இயக்கப்படும். இதற்குப் பிறகு, 'எண்' முழு எண் மாறியைத் தொடங்குகிறோம், அதில் சில கணித செயல்பாடுகளைப் பயன்படுத்துகிறோம் மற்றும் 'எண்' முடிவைக் காண்பிக்கிறோம்.
குறியீடு 3:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக எண்_01 = நான்கு. ஐந்து , எண்_02 = 62 , அ = 3 ;
bool b_01 , b_02 , b_03 ;
b_01 = எண்_01 == எண்_01 ;
b_02 = எண்_01 == எண்_02 ;
b_03 = எண்_02 > எண்_01 ;
கூட் << 'முதல் Bool b_01 இன் பதில் =' <<
b_01 << endl ;
கூட் << 'இரண்டாவது Bool b_02 இன் பதில் =' <<
b_02 << endl ;
கூட் << 'மூன்றாவது Bool b_03 இன் பதில் =' <<
b_03 << endl ;
bool b_a = உண்மை ;
என்றால் ( b_a )
கூட் << 'ஆம்' << endl ;
வேறு
கூட் << 'இல்லை' << endl ;
முழு எண்ணாக ஒன்றில் = பொய் + 7 * அ - b_a + உண்மை ;
கூட் << ஒன்றில் ;
திரும்ப 0 ;
}
வெளியீடு:
இந்த முடிவு எங்கள் குறியீட்டில் நாங்கள் செயல்படுத்திய செயல்பாடுகளின் முடிவுகளைக் காட்டுகிறது. எனவே, இந்த வழியில், இந்த 'பூலியன் தரவு வகையை' எங்கள் C++ குறியீடுகளில் பயன்படுத்துகிறோம்.
எடுத்துக்காட்டு 4:
இங்கே, 'isHotDay' ஐ 'bool' மாறியாகத் தட்டச்சு செய்து 'false' என்று துவக்குகிறோம். இப்போது, நாம் 'if' அறிக்கையைப் பயன்படுத்துகிறோம் மற்றும் நிபந்தனையாக 'isHotDay' ஐ அனுப்புகிறோம். 'isHotDay' நிபந்தனை பூர்த்தி செய்யப்பட்டால், 'if' என்பதைத் தொடர்ந்து வரும் அறிக்கை இப்போது செயல்படுத்தப்படும். இல்லையெனில், 'வேறு' பகுதி இந்த கட்டத்தில் இயங்கும்.
இப்போது, எங்களிடம் “DoTask” பூலியன் மாறி உள்ளது மற்றும் அதை “true” என அமைக்கவும். மேலும், 'Task_count' என்ற பெயரிடப்பட்ட 'int' மாறியையும் துவக்குகிறோம். இதற்குப் பிறகு, நாம் 'while ()' வளையத்தை வைக்கிறோம். இந்த “while()” லூப்பில், “DoTask” ஐ நிபந்தனையாக வைக்கிறோம். while லூப்பின் உள்ளே, 'Task_count++' என்று எழுதுகிறோம், இது 'Task_count' இன் மதிப்பை 1 ஆல் அதிகரிக்கிறது.
இந்த அறிக்கை செயல்படுத்தப்படும் போது, 'Task_count' இன் மதிப்பு 1 ஆல் அதிகரிக்கிறது. பின்னர், அடுத்த 'cout' அறிக்கை செயல்படுத்தப்படும். இதற்குப் பிறகு, 'Task_count < 9' என்ற நிபந்தனையை மீண்டும் வைக்கிறோம், மேலும் இந்த நிபந்தனையை 'DoTask' மாறிக்கு ஒதுக்குவோம். 'Task_count' '9' ஐ விட குறைவாக இருக்கும் வரை இந்த லூப் வேலை செய்யும்.
குறியீடு 4:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
bool isHotDay = பொய் ;
என்றால் ( ஹாட் டே ) {
கூட் << 'இது ஒரு சூடான நாள்!' << endl ;
} வேறு {
கூட் << 'இது வெப்பமான நாள் அல்ல' << endl ;
}
bool DoTask = உண்மை ;
முழு எண்ணாக பணி_எண்ணிக்கை = 0 ;
போது ( DoTask ) {
பணி_எண்ணிக்கை ++;
கூட் << 'பணி இங்கே தொடர்கிறது' << பணி_எண்ணிக்கை << endl ;
DoTask = ( பணி_எண்ணிக்கை < 9 ) ;
}
திரும்ப 0 ;
}
வெளியீடு:
இந்த வெளியீடு எங்கள் குறியீட்டின் மூலம் நாங்கள் இயக்கிய ஒவ்வொரு செயலின் முடிவையும் காட்டுகிறது. எனவே, இந்த 'பூலியன் தரவு வகையை' எங்கள் C++ குறியீடுகளில் இந்த முறையில் பயன்படுத்துகிறோம்.
எடுத்துக்காட்டு 5:
இப்போது, இந்த டுடோரியலின் கடைசி உதாரணத்தை நோக்கி நகர்கிறோம். இங்கே, நாம் மூன்று தனித்துவமான பூலியன் மாறிகளை எடுத்து இரண்டையும் அச்சிடுகிறோம். இதற்குப் பிறகு, இந்த பூலியன் மாறிகளில் 'AND', 'OR' மற்றும் 'NOT' ஆபரேட்டர்களைப் பயன்படுத்துகிறோம். மேலும், அனைத்து செயல்பாடுகளின் முடிவும் பூலியன் வடிவத்தில் சேமிக்கப்படுகிறது, ஏனெனில் இந்த செயல்பாடுகளின் முடிவு சேமிக்கப்படும் அனைத்து மாறிகளுடன் 'பூல்' ஐ சேர்த்துள்ளோம். இதற்குப் பிறகு, இந்த செயல்பாடுகளின் முடிவை மீண்டும் பூலியனில் அச்சிடுகிறோம்.
குறியீடு 5:
# அடங்கும்பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( )
{
பூல் மதிப்பு_1 = உண்மை ;
பூல் மதிப்பு_2 = பொய் ;
பூல் மதிப்பு_3 = உண்மை ;
கூட் << 'மதிப்பு_1' << மதிப்பு_1 << endl ;
கூட் << 'மதிப்பு_2' << மதிப்பு_2 << endl ;
கூட் << 'மதிப்பு_3' << மதிப்பு_3 << endl << endl ;
பூல் விளைவு_1 = ( மதிப்பு_1 || மதிப்பு_3 ) && மதிப்பு_1 ;
பூல் விளைவு_2 = மதிப்பு_1 && மதிப்பு_2 ;
பூல் விளைவு_3 = மதிப்பு_2 || மதிப்பு_3 ;
பூல் விளைவு_4 = ! மதிப்பு_3 ;
பூல் விளைவு_5 = ! மதிப்பு_2 ;
பூல் விளைவு_6 = ! மதிப்பு_1 ;
கூட் << 'முடிவு 1 =' << விளைவு_1 << endl ;
கூட் << 'முடிவு 2 =' << விளைவு_2 << endl ;
கூட் << 'முடிவு 3 =' << விளைவு_3 << endl ;
கூட் << 'முடிவு 4 =' << விளைவு_4 << endl ;
கூட் << 'முடிவு 5 =' << விளைவு_5 << endl ;
கூட் << 'முடிவு 6 =' << விளைவு_6 << endl ;
}
வெளியீடு:
இதோ முடிவு. ஒவ்வொரு செயல்பாட்டின் முடிவும் '0' மற்றும் '1' வடிவத்தில் காட்டப்படுவதை நாம் கவனிக்கலாம், ஏனெனில் 'பூல்' தரவு வகை பயன்படுத்தப்படுகிறது.
முடிவுரை
இந்த டுடோரியலில், C++ இல் பூலியன் தரவு வகை எவ்வாறு பயன்படுத்தப்படுகிறது மற்றும் பூலியன் தரவு வகையின் விளைவு என்ன என்பதை நாங்கள் விளக்கினோம். இந்த பூலியன் தரவு வகையைப் பயன்படுத்திய உதாரணங்களை ஆராய்ந்தோம். இந்த பூலியன் தரவு வகை பயனுள்ளது மற்றும் நேரடியானது என்பதை நாங்கள் கண்டோம், ஆனால் தவறுகளைத் தடுக்க கவனமாகப் பயன்படுத்துவது அவசியம்.