బూలియన్ C లో విలువలు చాలా సాధారణం, మరియు వాటి వినియోగాన్ని అర్థం చేసుకోవడం వలన మీ కోడ్‌ను మరింత సమర్థవంతంగా మరియు సులభంగా చదవగలిగేలా చేయవచ్చు. ఒక సాఫ్ట్‌వేర్‌లో తీర్పులు ఇవ్వడానికి బూలియన్ విలువ ఉపయోగించబడవచ్చు, ఎందుకంటే ఇది నిజం లేదా తప్పు కావచ్చు. ఇది C లోని ప్రాథమిక డేటా రకాల్లో ఒకటి.
బూలియన్ లూప్ నియంత్రణ మరియు షరతుల నుండి మెమరీ కేటాయింపు మరియు డేటా నిర్మాణం అమలు వరకు అనేక విభిన్న సందర్భాలలో విలువలు ఉపయోగపడతాయి. 'AND', 'OR' మరియు 'NOT' వంటి లాజిక్ ఆపరేటర్‌లతో ఉపయోగించినప్పుడు బూలియన్ అప్లికేషన్ యొక్క ప్రవర్తనను నియంత్రించడానికి లేదా పరిస్థితులను పరీక్షించడానికి లేదా నిర్ణయాలు తీసుకోవడానికి ఉపయోగించే సంక్లిష్ట వ్యక్తీకరణలను విలువలు సృష్టించగలవు.
ఈ కథనం ఉపయోగించడానికి వివరణాత్మక గైడ్ బూలియన్ సి ప్రోగ్రామింగ్‌లో విలువ.
C లో బూలియన్ విలువను ఉపయోగించండి
మీరు ఉపయోగించవచ్చు బూలియన్ C ప్రోగ్రామింగ్ భాషలో హెడర్ మరియు డేటా రకంతో లేదా అవి లేకుండా విలువలు. ఈ రెండు పద్ధతుల వివరాలను చూద్దాం.
విధానం 1: హెడర్ మరియు డేటా రకంతో బూలియన్ విలువను ఉపయోగించండి
ఉపయోగించడానికి బూలియన్ ఈ పద్ధతి ద్వారా విలువ, పేరుతో హెడర్ ఫైల్‌ను చేర్చడం మొదటి దశ 'stdbool.h' . ప్రధాన భాగం తర్వాత, వినియోగదారులు వేరియబుల్‌ను నిర్వచించాలి “ బూల్ ”ఇది రకం యొక్క వేరియబుల్‌ను నిర్వచిస్తుంది బూలియన్ . ఈ వేరియబుల్ 0 లేదా 1ని నిల్వ చేయగలదు, ఇది వరుసగా నిజమైన మరియు తప్పుడు ప్రకటనలను సూచిస్తుంది.
ఎలా ఉందో బాగా అర్థం చేసుకోవడానికి ఇప్పుడు ఒక సాధారణ ఉదాహరణ చూడండి బూలియన్ C లో డేటా రకం ఉపయోగించబడుతుంది.
##include
పూర్ణాంక ప్రధాన ( ) {
bool a = నిజం ;
ఉంటే ( a == నిజం ) {
printf ( 'ఒక విలువ నిజం' ) ;
} లేకపోతే {
printf ( 'A యొక్క విలువ తప్పు' ) ;
}
తిరిగి 0 ;
}
పై కోడ్‌లో, మేము టైప్ యొక్క వేరియబుల్‌ని నిర్వచించాము బూలియన్ bool కీవర్డ్‌ని ఉపయోగించి మరియు దానిని విలువతో ప్రారంభించింది నిజం . ఆ తర్వాత, వేరియబుల్ విలువను చూడటానికి కండిషన్ పరీక్షలను వర్తింపజేయడానికి మేము if-else బ్లాక్‌ని ఉపయోగించాము 'a' నిజం లేదా అబద్ధం.
అవుట్‌పుట్
విధానం 2: బూలియన్ హెడర్ ఫైల్ మరియు డేటా రకాన్ని ఉపయోగించకుండా బూలియన్ విలువను ఉపయోగించండి
బూలియన్ విలువలను ఉపయోగించకుండా కూడా నిర్వచించవచ్చు బూలియన్ శీర్షిక ఫైల్ మరియు డేటా రకం. ఈ సందర్భంలో, మేము మునుపటి ఉదాహరణలో వలె ప్రవర్తించే కొత్త డేటా రకాన్ని అభివృద్ధి చేయాలి.
లాజికల్ ఆపరేటర్లు దీనికి అనుసంధానించబడ్డారు బూలియన్ విలువ రకం. C భాషలో లాజికల్ ఆపరేటర్లలో మూడు విభిన్న వర్గాలు ఉన్నాయి:
-
- లాజికల్ ఆపరేటర్ && (AND ఆపరేటర్) ద్వారా రెండు ఆపరాండ్‌లు ఆమోదించబడ్డాయి. రెండు ఆపరాండ్ విలువలు నిజమైతే, ఈ ఆపరేటర్ ఒప్పు అని అందిస్తుంది; లేకపోతే, అది తప్పుగా తిరిగి వస్తుంది.
- ది || (OR ఆపరేటర్) లాజికల్ ఆపరేటర్ రెండు ఆపరాండ్‌లను తీసుకుంటాడు. రెండు ఒపెరాండ్‌ల విలువలు తప్పు అయితే, అది తప్పుని అందిస్తుంది; లేకుంటే, అది నిజమవుతుంది.
- '!' అనే ఆపరేటర్‌తో NOT ఆపరేటర్ ద్వారా ఒక ఒపెరాండ్ మాత్రమే ఆమోదించబడింది. ఒపెరాండ్ విలువ నిజమైతే, అది తప్పు మరియు వైస్ వెర్సాను అందిస్తుంది.
మేము అమలు చేయడానికి ముందే నిర్వచించిన ఫంక్షన్‌లను ఉపయోగించాల్సిన అవసరం లేదు బూల్ . ఒక ఉదాహరణ చూద్దాం.
#పూర్ణాంక ప్రధాన ( ) {
int x, y;
printf ( 'రెండు పూర్ణాంకాలు టైప్ చేయండి: \n ' ) ;
స్కాన్ఎఫ్ ( '%d%d' , & x, & మరియు ) ;
int x_positive = ( x > 0 ) ;
int y_positive = ( మరియు > 0 ) ;
ఉంటే ( x_పాజిటివ్ && y_పాజిటివ్ ) {
printf ( 'రెండు విలువలు సానుకూలంగా ఉన్నాయి. \n ' ) ;
} లేకపోతే ఉంటే ( x_పాజిటివ్ || y_పాజిటివ్ ) {
printf ( 'విలువలలో ఒకటి సానుకూలమైనది. \n ' ) ;
} లేకపోతే {
printf ( 'రెండు విలువలు ప్రతికూలంగా ఉన్నాయి. \n ' ) ;
}
తిరిగి 0 ;
}
పై కోడ్‌లో, మేము రెండు వేరియబుల్స్‌ని ఉపయోగిస్తున్నాము x మరియు మరియు , మరియు అవి సానుకూలంగా ఉన్నాయా లేదా ప్రతికూలంగా ఉన్నాయా అని తనిఖీ చేయడం. రెండు వేరియబుల్స్ సానుకూలంగా ఉంటే (దీనిని AND ఆపరేటర్ తనిఖీ చేయవచ్చు), కోడ్ ముద్రిస్తుంది 'రెండు విలువలు సానుకూలంగా ఉన్నాయి' . వాటిలో ఒకటి ప్రతికూలంగా ఉంటే, కోడ్ అవుట్‌పుట్‌లు (దీనిని OR ఆపరేటర్ తనిఖీ చేయవచ్చు) 'విలువలలో ఒకటి సానుకూలమైనది' . రెండూ ప్రతికూలంగా ఉంటే, కోడ్ అవుట్‌పుట్‌ను ప్రింట్ చేస్తుంది, 'రెండు విలువలు ప్రతికూలంగా ఉన్నాయి' .
అవుట్‌పుట్
ముగింపు
బూలియన్ వేరియబుల్స్ కోడ్ యొక్క ప్రవాహాన్ని నియంత్రించే శక్తివంతమైన, సమర్థవంతమైన మార్గాన్ని అందిస్తాయి మరియు మెమరీ కేటాయింపు మరియు డేటా స్ట్రక్చర్ మానిప్యులేషన్ వంటి క్లిష్టమైన పనుల కోసం ఇతర డేటా రకాలతో కలిపి ఉపయోగించవచ్చు. వినియోగదారులు బూలియన్ విలువను హెడర్ ఫైల్ మరియు డేటా రకంతో లేదా అవి లేకుండా ఉపయోగించవచ్చు. రెండు పద్ధతులు ఇప్పటికే పైన పేర్కొన్న మార్గదర్శకాలలో చర్చించబడ్డాయి.