C++ బూలియన్ రకం

ఉదాహరణ 1:

ఇప్పుడు, మనం ఈ “బూలియన్ డేటా రకాన్ని” ఉపయోగించుకునే కొన్ని ఉదాహరణలను అమలు చేయండి మరియు ఇది C++లో పని చేస్తుందని చూపిద్దాం. మనకు అవసరమైన హెడర్ ఫైల్‌లను జోడించడం ద్వారా మేము మా కోడ్‌ను ప్రారంభిస్తాము. మేము ఇక్కడ జోడించే మొదటి హెడర్ ఫైల్ “ ” ఇది డేటాను ఇన్‌పుట్ చేయడం లేదా అవుట్‌పుట్ చేయడంలో సహాయపడుతుంది. దీని తర్వాత, మనకు “std” నేమ్‌స్పేస్ ఉంటుంది; ఇది ప్రామాణిక పేరు.

దీని తర్వాత, మనకు డ్రైవర్ కోడ్ ఉంది అంటే మనం ఇక్కడ “main()” ఫంక్షన్‌ని జోడిస్తాము. ఇప్పుడు, మేము బూలియన్ డేటాటైప్ “బూల్”తో “isBulbOn” వేరియబుల్‌ని ప్రకటించాము మరియు ఇక్కడ “true”ని సర్దుబాటు చేస్తాము. దీని క్రింద, మనకు 'isBulbOff' అనే పేరు గల మరొక బూలియన్ వేరియబుల్ ఉంది, దీనిలో మనం 'false'ని జోడిస్తాము. ఈ నిజమైన మరియు తప్పుడు ఫలితాలు వరుసగా “1” మరియు “0”.

ఈ బూలియన్ విలువల అవుట్‌పుట్‌ను తనిఖీ చేయడానికి, మేము వాటిని “కౌట్” స్టేట్‌మెంట్‌ని ఉపయోగించి ప్రింట్ చేస్తాము. ఈ “కౌట్” స్టేట్‌మెంట్‌లో, మేము మొదట “isBulbOn” ఫలితాన్ని ప్రింట్ చేస్తాము. తరువాత, తదుపరి పంక్తిలో, మేము 'isBulbOff' వేరియబుల్ యొక్క ఫలితాన్ని ముద్రిస్తాము. “endl” ఇక్కడ ఉపయోగించబడుతుంది కాబట్టి ఇది మా పాయింటర్‌ను తదుపరి పంక్తికి తరలిస్తుంది.

కోడ్ 1:

అవుట్‌పుట్:

ఈ కోడ్ యొక్క అవుట్‌పుట్ కింది వాటిలో చూపిన విధంగా “0” మరియు “1” ఫారమ్‌లలో ఫలితాన్ని సూచిస్తుంది. ఇక్కడ, “1” “నిజమైన” ఫలితాన్ని సూచిస్తుంది, అయితే “0” “తప్పుడు” ఫలితాన్ని సూచిస్తుంది. 'బూల్' డేటా రకం కారణంగా మేము ఈ ఫలితాన్ని పొందుతాము.

ఉదాహరణ 2:

ఇప్పుడు, మేము ఈ కోడ్ ప్రారంభంలో హెడర్ ఫైల్‌ను చేర్చిన తర్వాత మెయిన్‌లోని “బూల్” డేటాటైప్‌లోని “పాస్” మరియు “ఫెయిల్” అనే రెండు వేరియబుల్‌లను ప్రకటిస్తాము. ఇక్కడ “పాస్” వేరియబుల్ “ట్రూ” అని కేటాయించబడింది మరియు “ఫెయిల్” వేరియబుల్ “తప్పు”గా కేటాయించబడింది. ఇప్పుడు, 'పాస్' ఫలితంగా '1'ని అందిస్తుంది మరియు 'ఫెయిల్' '0'ని అందిస్తుంది.

ఇప్పుడు, '1' మరియు '0' రూపంలో నిజమైన లేదా తప్పుడు ఫలితాన్ని పొందడానికి మా 'కౌట్' స్టేట్‌మెంట్‌లో ఈ బూల్ వేరియబుల్స్‌ని ఉపయోగిస్తాము. మనం 'పాస్' పెట్టే 'కౌట్' '1'ని అందిస్తుంది. మనం ఎక్కడ “ఫెయిల్” ఉపయోగిస్తే అక్కడ “0” వస్తుంది. ఇక్కడ, మేము ఐదు 'కౌట్' స్టేట్‌మెంట్‌లను జోడిస్తాము, ప్రతి ఒక్కటి బూలియన్ వేరియబుల్‌ను కలిగి ఉంటుంది.

కోడ్ 2:

అవుట్‌పుట్:

ఈ అవుట్‌పుట్‌లో, “1” “నిజమైన” ఫలితాన్ని సూచిస్తుంది, ఇది “పాస్” మరియు “0” ఈ సందర్భంలో “ఫెయిల్” అయిన “తప్పుడు” ఫలితాన్ని సూచిస్తుంది.

ఉదాహరణ 3:

ఈ కోడ్‌లో, మేము వరుసగా “45”, “62” మరియు “3” విలువతో “num_01”, “num_02” మరియు “a” అనే మూడు పూర్ణాంక వేరియబుల్‌లను ప్రారంభిస్తాము. దీని తర్వాత, మేము మరో మూడు వేరియబుల్‌లను ప్రకటిస్తాము - “b_01”, “b_02” మరియు “b_03” – మరియు ఇవి బూలియన్ డేటాటైప్ “బూల్”. ఇప్పుడు, మేము “b_01”ని “num_01 == num_01” కండిషన్‌తో ప్రారంభిస్తాము. అప్పుడు, మేము “b_02” మరియు “b_03”ని “b_01” మాదిరిగానే ప్రారంభిస్తాము.

అన్ని వేరియబుల్‌లను ప్రారంభించిన తర్వాత, ఈ బూలియన్ వేరియబుల్స్ ఫలితాన్ని తనిఖీ చేయడానికి మేము వాటిని 'కౌట్' ఉపయోగించి విడిగా ప్రింట్ చేస్తాము. దీని తరువాత, మేము 'బూల్' డేటా రకం యొక్క 'b_a' వేరియబుల్‌ను 'ట్రూ'తో ప్రారంభిస్తాము. అప్పుడు, మేము ఇక్కడ “b_a”ని షరతుగా ఉంచే “if” స్టేట్‌మెంట్‌ను ఉపయోగిస్తాము. ఇప్పుడు, ఈ “b_a” షరతు నిజమైతే, “if” తర్వాత స్టేట్‌మెంట్ అమలు చేయబడుతుంది. లేకపోతే, ఇక్కడ 'వేరే' భాగం అమలు అవుతుంది. దీని తరువాత, మేము 'num' పూర్ణాంక వేరియబుల్‌ను కొనసాగిస్తాము మరియు ప్రారంభించాము, దీనిలో మేము కొన్ని గణిత కార్యకలాపాలను వర్తింపజేస్తాము మరియు 'num' ఫలితాన్ని ప్రదర్శిస్తాము.

కోడ్ 3:

అవుట్‌పుట్:

ఈ ఫలితం మా కోడ్‌లో మేము అమలు చేసిన ఆపరేషన్ల ఫలితాలను చూపుతుంది. కాబట్టి, ఈ విధంగా, మన C++ కోడ్‌లలో ఈ “బూలియన్ డేటా రకాన్ని” ఉపయోగిస్తాము.

ఉదాహరణ 4:

ఇక్కడ, మేము 'isHotDay'ని 'bool' వేరియబుల్‌గా టైప్ చేసి, దానిని 'false'తో ప్రారంభించాము. ఇప్పుడు, మేము “if” స్టేట్‌మెంట్‌ని ఉపయోగిస్తాము మరియు “isHotDay”ని షరతుగా పాస్ చేస్తాము. 'isHotDay' షరతు సంతృప్తి చెందినట్లయితే 'if'ని అనుసరించే ప్రకటన ఇప్పుడు అమలు చేయబడుతుంది. లేకపోతే, ఈ సమయంలో 'వేరే' భాగం అమలు అవుతుంది.

ఇప్పుడు, మనకు “DoTask” బూలియన్ వేరియబుల్ ఉంది మరియు దానిని “true”కి సెట్ చేసాము. అంతేకాకుండా, మేము 'Task_count' పేరుతో 'int' వేరియబుల్‌ని కూడా ప్రారంభిస్తాము. దీని తరువాత, మేము 'వేళ ()' లూప్ను ఉంచుతాము. ఈ “while()” లూప్‌లో, మేము “DoTask”ని షరతుగా ఉంచాము. while లూప్ లోపల, మేము “Task_count++” అని వ్రాస్తాము, ఇది “Task_count” విలువను 1 ద్వారా పెంచుతుంది.

ఈ స్టేట్‌మెంట్ అమలు చేయబడినప్పుడు, “Task_count” విలువ 1 ద్వారా పెరుగుతుంది. తర్వాత, తదుపరి “cout” స్టేట్‌మెంట్ అమలు చేయబడుతుంది. దీని తర్వాత, మేము 'Task_count < 9' అనే షరతును మళ్లీ ఉంచుతాము మరియు ఈ షరతును 'DoTask' వేరియబుల్‌కు కేటాయించాము. 'Task_count' '9' కంటే తక్కువగా ఉండే వరకు ఈ లూప్ పని చేస్తుంది.

కోడ్ 4:

అవుట్‌పుట్:

ఈ అవుట్‌పుట్ మేము మా కోడ్ ద్వారా అమలు చేసిన ప్రతి చర్య యొక్క ఫలితాన్ని ప్రదర్శిస్తుంది. అందువలన, మేము ఈ పద్ధతిలో మా C++ కోడ్‌లలో ఈ “బూలియన్ డేటా రకాన్ని” కూడా ఉపయోగిస్తాము.

ఉదాహరణ 5:

ఇప్పుడు, మేము ఈ ట్యుటోరియల్ యొక్క చివరి ఉదాహరణ వైపు వెళ్తాము. ఇక్కడ, మేము మూడు ప్రత్యేకమైన బూలియన్ వేరియబుల్స్ తీసుకొని రెండింటినీ ప్రింట్ చేస్తాము. దీని తర్వాత, మేము ఈ బూలియన్ వేరియబుల్స్‌పై “AND”, “OR” మరియు “NOT” ఆపరేటర్‌లను వర్తింపజేస్తాము. అలాగే, అన్ని కార్యకలాపాల ఫలితం బూలియన్ రూపంలో నిల్వ చేయబడుతుంది ఎందుకంటే ఈ ఆపరేషన్ల ఫలితం నిల్వ చేయబడిన అన్ని వేరియబుల్స్‌తో మేము 'బూల్'ని జోడించాము. దీని తర్వాత, మేము ఈ ఆపరేషన్ల ఫలితాన్ని మళ్లీ బూలియన్‌లో ముద్రిస్తాము.

కోడ్ 5:

అవుట్‌పుట్:

ఇక్కడ ఫలితం ఉంది. 'బూల్' డేటా రకం ఉపయోగించబడినందున ప్రతి ఆపరేషన్ ఫలితం '0' మరియు '1' రూపంలో ప్రదర్శించబడుతుందని మేము గమనించవచ్చు.

ముగింపు

ఈ ట్యుటోరియల్‌లో, బూలియన్ డేటా రకం C++లో ఎలా ఉపయోగించబడుతుందో మరియు బూలియన్ డేటా రకం యొక్క ఫలితం ఏమిటో మేము ప్రదర్శించాము. మేము ఈ బూలియన్ డేటా రకాన్ని ఉపయోగించిన ఉదాహరణలను అన్వేషించాము. ఈ బూలియన్ డేటా రకం ప్రభావవంతంగా మరియు సూటిగా ఉంటుందని మేము చూశాము, అయితే పొరపాట్లను నివారించడానికి దీన్ని జాగ్రత్తగా ఉపయోగించడం చాలా అవసరం.