Bitvis operatører i C

I dette Linux hint Artikkel, alt om bitvis logiske operasjoner blir forklart. Ved å bruke et praktisk eksempel med bildekodefragmenter, vil vi se i detalj hver av de logiske operatørene som brukes på C -språket.

Vi vil også forklare hvordan du utfører bitmaskering med logiske operasjoner, da dette er noe veldig nyttig i programmering og er helt relatert til denne typen operatører.

Beskrivelse av bitvis operasjoner

Operasjonene bitvis er logiske og skiftoperasjoner brukes individuelt på hver bit av en variabel. For eksempel, hvis vi bruker operasjonen og mellom variablene “A” og “B”, vil bit 0 av “A” være koblet til bit 0 av “B”, vil bit 1 av “A” være koblet til bit 1 av “B” “, og så videre.

Hver bit opererer og returnerer sitt eget resultat og har ingen innflytelse på resultatet av bitene ved siden av.

Denne typen operasjoner er veldig nyttig i maskeringsbiter når du bruker kontrollflagg eller indikatorer gruppert i et enkelt dataelement, for eksempel et heltall.

Hvordan tilordne en binær verdi til en variabel på C -språket

Før vi begynner å forklare hvilke bitvise logiske operasjoner som handler om, la oss se på hvordan vi kan tilordne en verdi til en variabel i binær kode, selv om vi kan gjøre dette i desimal, heksadesimal eller annen representasjon, gjør det å visualisere 1S og 0 -er programmering mye mer praktisk og forståelig. For eksempel i tilfeller der bitene representerer kontrollflagg eller indikatorer gruppert i en int, dobbel eller annen variabel.

For å tilordne en verdi til en variabel i binært format, må vi prefiksere den binære representasjonen med “0b”. Følgende utdrag tilordner verdien 131 eller 0B10000011 til heltallet “A” i binært format og viser deretter sin desimalrepresentasjon i kommandokonsollen.

#inkludere
void main ()
int a;
A = 0B10000011;
printf ("Desimalrepresentasjonen for 0B10000011 er: %i \ n", a);

Bildet nedenfor viser resultatet for denne koden.

Å representere binære verdier i bitvis og maskering av programmering gjør mye mer flytende og forståelig og unngår feil eller konverteringer som koster tid.

Ikke operatør

Den logiske operatøren for ikke er symbolet "~".

Den logiske ikke eller negasjonsoperasjonen er den enkleste av alle, og har bare en inngang og en utgang.

Denne operasjonen kommer tilbake i sin output den omvendte binære verdien av inngangen.

Tenk på følgende uttrykk for den logiske operasjonen ikke med inngangen “A”

c = ~ a

Resultatet i “C” er lik 1 hvis “A” er lik 0 og “C” er lik 0 hvis “A” er lik 1. Denne operasjonen brukes ofte for å oppnå den komplementære verdien av en variabel.

La oss deretter se på sannhetsbordet for ikke -operasjonen.

en	~	=	c
0	~	=	1
1	~	=	0

Eksempel:

I dette eksemplet vil vi bruke operasjonen ikke på variabelen A for å få sin komplement i “C”

For å gjøre dette oppretter vi variabelen A av typen usignert røye, tilordner den verdien 131 og får resultatet i “C”. Vi bruker deretter printf () -funksjonen for å vise resultatet i kommandokonsollen. Nedenfor kan vi se koden for dette formålet.

#inkludere
tomrom ()

usignert char c;
usignert char a;
A = 0B01111100;
c = ~ a;
printf (“\ n den desimale representasjonen for 0B10000011 er: %i \ n”, c);

I figuren nedenfor ser vi resultatet av komplementet til “A” . I dette tilfellet er komplementet eller inverse av 131 124 eller 01111100 i binær representasjon.

Logisk og operatør

Den logiske operatøren for og operasjonen er symbolet “&”

La oss se på følgende uttrykk for logisk og drift mellom variablene A og B

C = A & B.

Resultatet i “C” er lik 1 bare hvis “A” og “B” er lik 1. I alle andre tilfeller er “C” lik 0.

Deretter ser vi på sannhetstabellen for operasjonen og.

EN	Og	b	=	c
0	Og	0	=	0
0	Og	1	=	0
1	Og	0	=	0
1	Og	1	=	1

Den logiske operasjonen og er veldig nyttig i bitmaskering. Senere vil vi se et avsnitt som forklarer denne teknikken mer detaljert.

Eksempel:

La oss nå se et eksempel der vi utfører den logiske og driften mellom variablene “A” og “B” av typen usignert røye og lagrer resultatet i “C” for å vise det senere i kommandokonsollen.

Vi tildeler verdien 135 eller 10000111 til variabelen “A” og 129 eller 1000001 til variabelen “B” i binær representasjon. Deretter vil vi bruke operatøren "&" "til å utføre operasjonen. Deretter vil vi se koden for dette.

#inkludere
tomrom ()

usignert char a = 0B10000111;
usignert char b = 0B10000001;
usignert char c;
c = a & b;
printf ("\ n resultatet av A&B er: %i \ n", c);

Bildet viser resultatet av denne koden der og driften mellom “A” og “B” resulterer i 129 eller 10000001 i binær.

Logisk eller operatør

Den logiske operatøren for OR -operasjonen er symbolet ”| “.

La oss se på følgende uttrykk for logisk eller drift mellom variablene A og B

c = til | b.

Resultatet i “C” vil være lik 1 bare hvis “A” eller “B” eller “A” og “B” lik 1, mens det bare vil være 0 bare hvis "A" og "B" begge er lik 0.

La oss deretter se på sannhetstabellen for OR -operasjonen.

til	|	b	=	c
0	|	0	=	0
0	|	1	=	1
1	|	0	=	1
1	|	1	=	1

Eksempel

I dette eksemplet vil vi se hvordan du utfører den logiske operasjonen eller mellom variablene ”A” og “B” av typen usignert røye og lagrer resultatet i “C” for å vise den senere i kommandokonsollen.

Vi tildeler verdien 128 eller 10000000 til variabelen “A” og 3 eller 00000011 til variabelen “B” i binær representasjon. Deretter vil vi bruke operatøren “|” til å utføre operasjonen. Deretter vil vi se koden for denne operasjonen.

#inkludere
tomrom ()

usignert char A = 0B10000000;
usignert char b = 0B00000011;
usignert char C;
c = til | b;
printf ("\ n resultatet av a | b er: %i \ n", c);

På bildet nedenfor ser vi resultatet av operasjonen C = A | B som i dette tilfellet er 131 eller 10000011 i binær.

Logisk operatør XOR eller eksklusiv eller

Den logiske operatøren for XOR -operasjonen er symbolet ” ^“.

La oss se på følgende uttrykk for den logiske XOR -operasjonen mellom variablene A og B

c = a ^ b.

Resultatet i “C” er lik 1 bare hvis en av bitene “A” eller “B” er lik 1, men det er 0 hvis “A” og “B” begge er lik 1 eller lik 0.

Denne operasjonen er essensiell i Adders fordi i binært system 1 + 0 = 1 eller 0 + 1 er også lik 1. Men 1 + 1 = 0 med bære til neste høyere bit. I dette tilfellet utføres gjennomføringen av operasjonen og.

Deretter ser vi på sannhetstabellen for XOR -operasjonen.

en	^	b	=	c
0	^	0	=	0
0	^	1	=	1
1	^	0	=	1
1	^	1	=	0

Eksempel

La oss nå se på et eksempel der vi utfører den logiske XOR -operasjonen mellom variablene ”A” og “B” av typen usignert røye og lagrer resultatet i “C” for å vise den senere i kommandokonsollen.

Vi tildeler verdien 135 eller 10000111 til variabelen “A” og 3 eller 00000011 til variabelen “B” i binær notasjon. Deretter vil vi bruke " ^" -operatøren til å utføre den logiske operasjonen. Deretter vil vi se koden for dette.

#inkludere
tomrom ()

usignert char a = 0B10000111;
usignert char b = 0B00000011;
usignert char c;
c = a ^ b;
printf ("\ n resultatet av a | b er: %i \ n", c);

Som vi kan se på bildet, er resultatet 10000100 og bitene hvis to innganger er = 1 xor resulterer i 0.

Operatører med oppgave

Operatørene med oppdrag utfører de samme logiske operasjonene som vi så før, men resultatet er lagret i operanden som går foran operatøren.

Følgende uttrykk utfører logisk og drift mellom variabelen “A” og variabelen eller verdien som er tilordnet etter operatøren, og resultatet returneres i “A”.

A & = 55;

Rotasjonsoperatører

Rotasjonsoperatørene er “< > “.

Disse operatørene forskyver dataene til en variabel med henholdsvis "n" biter til venstre eller høyre.

I det følgende uttrykket forskyver operatøren dataene som er lagret i “A” 5 biter til venstre.

a = a < < 5

Eksempel

I dette eksemplet vil vi tilordne verdien 0B000001 til variabelen “A” og deretter skifte 1 bit til venstre i en for sløyfe og sende ut den resulterende verdien i kommandokonsollen. Denne syklusen gjentas 8 ganger

#inkludere
tomrom ()

usignert char a = 0B00000001;
usignert char c;
for (int bit = 0; bit!= 8; bit ++)
printf ("%i \ n", a);
a = a<<1;

I det følgende bildet ser vi resultatet med desimalverdiene som tilsvarer hver plassering av bitene i en usignert karakter.

Bit maskering

I visse tilfeller, for eksempel når vi definerer flere kontrollflagg gruppert i et enkelt register, trenger vi bare å vite eller endre verdien på en eller flere biter, ikke hele registeret.

For å få status som en eller flere spesifikke biter, må vi definere en maske som bare setter bitene til elementene hvis verdi vi vil vite til 1 og bruke og operasjonen.

For eksempel, hvis vi ønsker å få verdien av bitene 0 og 2 av variabel “A”, må vi definere følgende maske og utføre og driften.

00000101

I dette tilfellet vil bare statusen til bitene 0 og 2 bli returnert som et resultat, de gjenværende bitene vil ha verdien = 0, uavhengig av hvilken verdi de har “a”.

For å endre verdien, må vi bruke eller driften mellom masken med bitene vi ønsker å sette til 1 og variabelen vi ønsker å endre. Hvis vi ønsker å sette den til 0, må vi invertere masken som vist nedenfor og bruke og operasjonen.

11111010

Eksempel

I dette eksemplet bruker vi bitmaskering for å lage en enkel og praktisk omformer fra desimaltall til en streng med sin binære representasjon.

For denne samtalen vil vi bruke 8 masker, en for hver bit, men for å gjøre programmeringen mer praktisk og tydeligere, vil vi først bruke masken 10000000 og deretter flytte en bit til høyre i hver syklus av løkken. På denne måten vil vi få følgende 8 masker som vi trenger.

10000000
01000000
00100000
00010000
00001000
00000100
00000010
00000001

Omformeren består av en for loop med 8 sykluser, hvorav den spør om statusen til den tilsvarende bit. Dette gjøres av en og drift mellom dataene som skal konverteres og den tilsvarende masken.

Hvis resultatet av operasjonen i "C" er 0, kan du sende ut denne verdien med printf () -funksjonen. Ellers, hvis verdien av biten er 1, vil den bli skrevet ut i kommandokonsollen.

Nedenfor er koden for denne praktiske omformeren.

#inkludere
void main ()
usignert røye A = 143;
usignert char b = 0B10000000;
usignert char c;
printf ("\ n den binære representasjonen av a er:");
for (int bit = 0; bit!= 8; bit ++)
c = a & b;
if (c == 0)
printf ("0");
ellers
printf ("1");
b = b >> 1;
c = 0;

printf ("\ n \ n");

I det følgende bildet ser vi nedenfor resultatet av konverteringen for nummeret 143.

Konklusjon

I dette Linux hint Artikkel, vi har forklart hver av de logiske og rotasjonsoperatørene som C -språket gir for bitvis behandling. For hver av disse operatørene har vi laget en seksjon som viser symbolet som brukes til den operatørbeskrivelsen og et praktisk eksempel med kodebiter og bilder for hver. Vi har også tatt med en seksjon som omhandler bitmaskering og hva som er et tillegg, som er helt relatert til logiske operasjoner av denne typen.