C++లో బూలియన్ వ్యక్తీకరణలను ఎలా ఉపయోగించాలి
C++లో, ఒక వ్యక్తీకరణను బూలియన్ వ్యక్తీకరణగా పిలుస్తారు, ఇది పరిస్థితులను అంచనా వేయడానికి మరియు నిజమైన లేదా తప్పు (0 లేదా 1) బూలియన్ విలువను ఉత్పత్తి చేయడానికి ఉపయోగించబడుతుంది. బూలియన్ వ్యక్తీకరణలను ఉపయోగించుకోవడానికి C++ మాకు రెండు ప్రధాన మార్గాలను అందిస్తుంది:
C++లో బూలియన్ వ్యక్తీకరణలను ఒక్కొక్కటిగా ఉపయోగించే పై పద్ధతిని చర్చిద్దాం.
పోలిక ఆపరేటర్లతో బూలియన్ వ్యక్తీకరణ
పోలిక ఆపరేటర్లు రెండు విలువలను సరిపోల్చారు మరియు బూలియన్ ఫలితాన్ని అందిస్తారు. C++లో మనకు వివిధ పోలిక ఆపరేటర్లు ఉన్నాయి ==, !=, <, >, <= మరియు >= . ఇవన్నీ రెండు వేరియబుల్‌లను సరిపోల్చడానికి ఉపయోగించబడతాయి మరియు ఆపరేషన్ ప్రకారం అవి నిజమైన (1) లేదా తప్పు (0)గా విలువలను అందిస్తాయి.
ను ఉపయోగించుకుందాం == C++ ప్రోగ్రామ్‌లో బూలియన్ వ్యక్తీకరణపై పోలిక ఆపరేటర్:
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
#
int ప్రధాన ( ) {
int a = 6 ;
బూల్ కూడా = ( a % 2 == 0 ) ;
ఉంటే ( కూడా ) {
కోట్ << 'నిజం' << endl ;
} లేకపోతే {
కోట్ << 'తప్పుడు' << endl ;
}
తిరిగి 0 ;
}
పై C++ కోడ్‌లో, అమలు మెయిన్ నుండి ప్రారంభమవుతుంది, ఇక్కడ నేను మొదట పూర్ణాంకాన్ని ప్రారంభించాను a విలువతో 6 . అప్పుడు, బూలియన్ డేటా రకాన్ని ఉపయోగించి, నేను ఒక ప్రారంభించాను కూడా బూలియన్ వ్యక్తీకరణను కలిగి ఉన్న వేరియబుల్ == ఆపరేటర్ ఒక షరతు పెట్టాడు. చివరికి, షరతులతో కూడిన నిర్మాణం ( ఉంటే-లేకపోతే ) షరతు సంతృప్తి చెందితే ఒప్పు అని తిరిగి వస్తుంది, లేకపోతే తప్పు అని తిరిగి వస్తుంది. వేరియబుల్ విలువ నుండి a 6 కాబట్టి నిజాన్ని అవుట్‌పుట్‌గా అందిస్తుంది:
లాజికల్ ఆపరేటర్లతో బూలియన్ వ్యక్తీకరణ
తార్కిక వ్యక్తీకరణలు బూలియన్ విలువలపై మాత్రమే పనిచేస్తాయి కాబట్టి నిర్దిష్ట వ్యక్తీకరణ నిజమా లేదా తప్పు కాదా అని తనిఖీ చేయడానికి C++లోని లాజికల్ ఆపరేటర్లు ఉపయోగించబడతాయి. లాజికల్ ఆపరేటర్లు విలువలను సరిపోల్చండి మరియు బూలియన్ నిబంధనలలో ఫలితాలను ఇస్తారు. సాధారణ లాజికల్ ఆపరేటర్లు ఉన్నాయి &&, II, మరియు, ! . వినియోగదారు టైప్ చేసిన పూర్ణాంకం 1 మరియు 15 మధ్య ఉందో లేదో నిర్ధారించడానికి AND (&&) ఆపరేటర్‌ని ఉపయోగించి లాజికల్ ఎక్స్‌ప్రెషన్‌లను ఉపయోగించే C++ కోడ్ యొక్క ఉదాహరణ క్రింద ఉంది:
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
కోట్ << 'దయచేసి ఒక అంకెను చొప్పించండి:' ;
int a ;
ఆహారపు >> a ;
ఉంటే ( a > 0 && a <= పదిహేను )
కోట్ << 'మీరు నమోదు చేసిన అంకె 1 మరియు 15 మధ్య ఉంది' ;
లేకపోతే
కోట్ << 'మీరు నమోదు చేసిన అంకె 1 మరియు 15 మధ్య లేదు' ;
తిరిగి 0 ;
}
ఇక్కడ, మొదటి దశలో, మేము వినియోగదారు నుండి అంకెలను తీసుకోవడానికి సందేశాన్ని ముద్రించాము కోట్ . అప్పుడు ప్రకటించారు int వేరియబుల్ a ఉపయోగించే వినియోగదారు నుండి ఇన్‌పుట్ తీసుకోవడానికి ఆహారపు . దీని తరువాత, నియత నిర్మాణం ఉంటే-లేకపోతే సహా ఒక షరతుతో ఉపయోగించబడుతుంది మరియు (&&) బూలియన్ వ్యక్తీకరణలో లాజికల్ ఆపరేటర్. ఈ షరతు నమోదు చేసిన అంకె 1 మరియు 15 మధ్య ఉందో లేదో తనిఖీ చేస్తుంది. రెండు షరతులు నిజమైతే, if స్టేట్‌మెంట్ తర్వాత సూచనలు అమలు చేయబడతాయి మరియు ఏవైనా షరతులు తప్పు అయితే, వేరే స్టేట్‌మెంట్ అమలు చేయబడుతుంది:
ముగింపు
బూలియన్ వ్యక్తీకరణలు C++ భాషలో విస్తృతంగా ఉపయోగించబడతాయి. వాటిని లాజికల్ మరియు కంపారిజన్ ఆపరేటర్లతో ఉపయోగించవచ్చు మరియు అవుట్‌పుట్‌ను ఒప్పు లేదా తప్పుగా అందించవచ్చు. పోలిక ఆపరేటర్లు, లాజికల్ ఆపరేటర్లు మరియు షరతులతో కూడిన నిర్మాణాల సహాయంతో మనం బూలియన్ వ్యక్తీకరణలను ఎలా అమలు చేయవచ్చో C++ యొక్క పై ఉదాహరణలలో చూశాము.