బిట్‌వైస్ మరియు ఆపరేటర్:
అత్యంత విస్తృతంగా ఉపయోగించే కాన్సెప్చువల్ బిట్‌వైస్ ఆపరేషన్లలో ఇది ఒకటి. ది & దానిని సూచించడానికి ఉపయోగించే ఒంటరి పెద్ద అక్షరం. (&) ఆపరేటర్ చివరలో, రెండు పూర్ణాంక ప్రకటనలు ఉన్నాయి. రెండు బిట్‌లకు బిట్ 1 ఉన్నప్పుడు, బిట్‌వైస్ మరియు ఫంక్షన్ ఫలితం 1; దీనికి విరుద్ధంగా, ఫలితం 0. దిగువ చిత్రం నుండి AND ఆపరేషన్ క్లియర్ చేయబడింది. X మరియు y రెండూ 1 అయినప్పుడు, ఫలితం కూడా 1. మీరు చూడవచ్చు, మరోవైపు, వాటిలో ఒకటి 1 మరియు మరొకటి 0 అయితే, ఫలితం 0.
ప్రారంభిద్దాం మరియు C భాషలో Bitwise AND (&) ఆపరేటర్ యొక్క కొన్ని ఉదాహరణలను చూద్దాం. ఈ ఆర్టికల్ అమలు సమయంలో, మేము ఉబుంటు 20.04 లైనక్స్ ఆపరేటింగ్ సిస్టమ్‌ను ఉపయోగించాము. మీకు ఒకటి ఉందో లేదో నిర్ధారించుకోండి gcc మీ సి కోడ్‌ను కంపైల్ చేయడానికి మీ లైనక్స్ సిస్టమ్‌లో కంపైలర్ ఇన్‌స్టాల్ చేయబడింది. కాకపోతే, కింది ఆదేశాన్ని ఉపయోగించండి:
$సుడోసముచితమైనదిఇన్స్టాల్ gcc
ఉదాహరణ 01:
C భాషలో AND ఆపరేటర్ యొక్క పనితీరును వివరించడానికి మా మొదటి ఉదాహరణను కలిగి ఉండండి. ఉబుంటు లైనక్స్ సిస్టమ్ నుండి లాగిన్ అయిన తర్వాత, మీరు కొత్త సి రకం ఫైల్‌ను సృష్టించడానికి టెర్మినల్ షెల్‌ను తెరవాలి. SO, ఉపయోగించండి Ctrl+Alt+T త్వరగా ప్రారంభించడానికి. లేకపోతే, మీరు మీ లైనక్స్ సిస్టమ్ యొక్క డెస్క్‌టాప్‌లోని కార్యాచరణ ప్రాంతం వైపు నావిగేట్ చేయవచ్చు. సెర్చ్ బార్ తెరిచిన తర్వాత, వ్రాయండి టెర్మినల్ మరియు ఎంటర్ నొక్కండి. పాప్-అప్ అప్లికేషన్ తెరవబడుతుంది. దీన్ని ప్రారంభించడానికి దానిపై నొక్కండి. ఇప్పుడు టెర్మినల్ షెల్ తెరవబడింది, క్రింద చూపిన విధంగా షెల్‌లోని టచ్ కమాండ్ ఉపయోగించి కొత్త సి-టైప్ ఫైల్‌ని సృష్టిద్దాం. మేము పేరు ఇచ్చాము పరీక్ష. సి సి ఫైల్‌కు:
$స్పర్శపరీక్ష. సి
ఇప్పుడు, ఫైల్ సృష్టించబడింది. ఉబుంటు 20.04 లైనక్స్ ఆపరేటింగ్ సిస్టమ్ యొక్క మీ హోమ్ డైరెక్టరీలో మీరు కొత్తగా సృష్టించిన ఫైల్‌ను చూడవచ్చు. మీరు ఫైల్‌ను తెరవవచ్చు పరీక్ష. సి టెర్మినల్‌లో దిగువన ఉన్న GNU నానో ఎడిటర్ ఆదేశాన్ని ఉపయోగించడం. కింది ఆదేశాన్ని వ్రాసి ఎంటర్ నొక్కండి:
$నానోపరీక్ష. సి
ఇప్పుడు, test.c ఫైల్ GNU నానో ఎడిటర్‌లో విడుదల చేయబడింది. దిగువ జోడించిన సి స్క్రిప్ట్‌ను అందులో వ్రాయండి. ఈ కోడ్‌లో ఇన్‌పుట్-అవుట్‌పుట్ స్టాండర్డ్ లైబ్రరీ హెడర్ ఉంటుంది. పనితీరును నిర్వహించడానికి ప్రధాన ఫంక్షన్ ఉపయోగించబడింది. స్వాగత సందేశాన్ని ప్రదర్శించడానికి మొదటి printf ప్రకటన ఉపయోగించబడుతుంది. తదుపరి లైన్‌లో, మేము రెండు పూర్ణాంక-రకం వేరియబుల్స్‌ను పేర్కొన్నాము. వేరియబుల్ విలువ x వేరియబుల్ కంటే ఎక్కువ మరియు . రెండు వేరియబుల్స్‌పై AND ఆపరేటర్ ఫలితాన్ని ప్రకటించడానికి మరొక ప్రింట్ స్టేట్‌మెంట్ ఉపయోగించబడింది x మరియు మరియు . ఆ తరువాత, ప్రధాన ఫంక్షన్ మూసివేయబడుతుంది. ఉపయోగించి మీ నానో ఫైల్‌ను సేవ్ చేయండి Ctrl+S కీ మరియు ద్వారా టెర్మినల్ షెల్ వైపు మళ్లీ నావిగేట్ చేయండి Ctrl+X కీ.
ముందుగా రెండు పూర్ణాంకాల బిట్ విలువలను చూద్దాం x మరియు మరియు . మేము రెండు వేరియబుల్స్ యొక్క బిట్ విలువలపై AND ఆపరేటర్‌ను వర్తింపజేసినప్పుడు x మరియు మరియు , అది ప్రదర్శించబడింది 000000 , దీని బిట్ విలువ 0. అంటే AND ఆపరేటర్ యొక్క అప్లికేషన్ తర్వాత మా సమాధానం 0 అయి ఉండాలి.
ఉపయోగించి టెర్మినల్ వద్ద C కోడ్‌ను కంపైల్ చేద్దాం gcc కంపైలర్ మరియు ఒక ఫైల్ పేరు, క్రింద జతచేయబడింది:
$gccపరీక్ష. సి 
ఇప్పుడు కోడ్ కంపైల్ చేయబడింది, దీనిని ఉపయోగించి రన్ చేద్దాం అవుట్‌పుట్ దిగువ ఆదేశం. స్వాగత సందేశం తర్వాత 36 మరియు 16 తేదీలలో AND ఆపరేటర్ ఫలితంగా ఇది 0 ని ప్రదర్శిస్తుందని మీరు చూడవచ్చు:
$./a. అవుట్ 
ఉదాహరణ 02:
కొన్ని పూర్ణాంక విలువలపై AND ఆపరేటర్ యొక్క పనితీరును చూడడానికి మరొక ఉదాహరణను చూద్దాం. అదే తెరవండి పరీక్ష. సి దిగువ నానో ఎడిటర్ ద్వారా టెర్మినల్ ఉపయోగించి ఫైల్:
$నానోపరీక్ష. సి 
ఫైల్‌ని అప్‌డేట్ చేద్దాం పరీక్ష. సి కింది కోడ్‌తో. ఫైల్‌లో ఇన్‌పుట్ మరియు అవుట్‌పుట్ స్టాండర్డ్ స్ట్రీమ్‌ని జోడించిన తర్వాత, మేము రిటర్న్ టైప్‌తో ప్రధాన పద్ధతిని పూర్ణాంకంగా ఉపయోగించాము. ప్రింట్ చేయడానికి మేము printf స్టేట్‌మెంట్‌ను జోడించాము స్వాగతం సందేశం. మరొక పూర్ణాంకం రకం వేరియబుల్, తో , 0. విలువతో డిక్లేర్ చేయబడింది తో . చివరి printf స్టేట్‌మెంట్ AND ఆపరేటర్ యొక్క సేవ్ చేసిన ఫలితాన్ని వేరియబుల్ ఉపయోగించి ప్రింట్ చేస్తోంది తో . మీ కోడ్‌ని సేవ్ చేయండి మరియు నానో ఎడిటర్‌ని వదలివేయండి Ctrl+S మరియు Ctrl+X తదనుగుణంగా.
మీరు రెండు పూర్ణాంకాల బిట్ విలువలను చూడవచ్చు యాభై మరియు 17 . యొక్క రెండు బిట్ విలువలపై AND ఆపరేటర్ యొక్క లెక్కించిన ఫలితం యాభై మరియు 17 ఫలితం 16 అని చూపిస్తుంది. అది సరైనదేనా అని చూద్దాం.
ద్వారా మీ కోడ్‌ని ముందుగా కంపైల్ చేయండి gcc కంపైలర్:
$gccపరీక్ష. సి 
కింది విధంగా అవుట్‌పుట్ ఆదేశాన్ని ఉపయోగించి test.c ఫైల్‌ను అమలు చేయండి. ఫలితం మేము ఊహించిన విధంగానే ఉందని మీరు చూడవచ్చు, ఉదా., 16:
$./a. అవుట్ 
ఉదాహరణ 03:
C లాంగ్వేజ్‌లో AND ఆపరేటర్ పని చేయడాన్ని చూడటానికి మా చివరి ఉదాహరణ తీసుకుందాం. ఫైల్‌ని తెరవండి పరీక్ష. సి మరోసారి షెల్‌లోని నానో ఎడిటర్‌ని ఉపయోగించడం:
$నానోపరీక్ష. సి 
అదే కోడ్‌ను అప్‌డేట్ చేయడానికి దిగువ మీ ఫైల్‌లో అతికించండి. మళ్లీ, మా కోడ్‌లోని ఇన్‌పుట్ మరియు అవుట్‌పుట్ స్టాండర్డ్ హెడర్ లైబ్రరీని ఉపయోగించి, మేము పూర్ణాంక రిటర్న్ టైప్‌తో ప్రధాన పద్ధతిని ఉపయోగించాము. ఈసారి మేము రెండు పూర్ణాంకాలను ఉపయోగించాము కానీ చిన్న మరియు అతిపెద్ద విలువల స్థానాన్ని మార్చాము. ప్రింట్ స్టేట్‌మెంట్ & ఆపరేటర్‌ను వర్తింపజేయడానికి మరియు ఫలితాన్ని ప్రదర్శించడానికి ఉపయోగించబడింది:
పూర్ణాంకాల రెండు బిట్ విలువలపై AND వర్తింపజేయడం యొక్క బిట్ ఫలితం 2.
Gcc కంపైలర్‌తో మీ కోడ్‌ని మరోసారి కంపైల్ చేయండి:
$gccపరీక్ష. సి 
కోడ్ సంకలనం తరువాత, ఫలితాలను చూడటానికి అవుట్‌పుట్ ఎగ్జిక్యూషన్ ఆదేశాన్ని అమలు చేయండి. ఫలితం మనం పైన పేర్కొన్న విధంగానే ఉంటుంది, ఉదా., 2.
$./a. అవుట్ 
ముగింపు:
ఈ ఆర్టికల్లో, AND ఆపరేటర్ లేదా పూర్ణాంక విలువలను వర్తింపజేయడం మరియు బిట్ విలువలపై ఇది ఎలా పనిచేస్తుంది అనే ఉదాహరణలను మీరు చూశారు. ఈ వ్యాసం మీకు ఉత్తమంగా సహాయపడిందని మేము ఆశిస్తున్నాము మరియు ఈ అంశంపై మీకు మరింత మార్గదర్శకత్వం అవసరం లేదు.