C Bittikohtaiset operaattorit: AND, OR, XOR, Shift & Täydennys (esimerkin kanssa)

Mitä ovat Bitwise-operaattorit?

BITWISE-KÄYTTÄJIÄ käytetään tietojen käsittelyyn bittitasolla, jota kutsutaan myös bittitason ohjelmoinniksi. Bituaalisesti toimii yksi tai useampi bittikuvio tai binääriluku niiden yksittäisten bittien tasolla. Niitä käytetään numeerisissa laskelmissa laskentaprosessin nopeuttamiseksi.

Seuraavassa on luettelo C-ohjelmointikielen tarjoamista bittikohtaisista operaattoreista:

Operaattori	Tarkoitus
&	Bittiviiva JA operaattori
\|	Bitwise OR-operaattori
^	Bittikohtainen yksinomainen TAI-operaattori
~	Binary One's Complement Operator on unary-operaattori
<<	Vasemman vaiheen operaattori
>>	Oikean vaiheen operaattori

Bittikohtaisia operaattoreita ei voida suoraan soveltaa primitiivisiin tietotyyppeihin, kuten float, double, jne. Muista aina yksi asia, jonka mukaan bittioperaattoreita käytetään enimmäkseen kokonaislukutietotyypin kanssa sen yhteensopivuuden vuoksi.

Bittikohtaiset loogiset operaattorit työskentelevät datan suhteen vähitellen, alkaen vähiten merkitsevästä bitistä, eli LSB-bitistä, joka on oikeanpuoleisin bitti, ja työskentelee kohti vasemmanpuoleista bittiä MSB: tä (Most Significant Bit).

Bittisuuntaisten loogisten operaattorien laskennan tulos on esitetty alla olevassa taulukossa.

x	y	x & y	x \| y	x y
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

Tässä opetusohjelmassa opit-

Mitä ovat Bitwise-operaattorit?
Bittikohtaisesti JA
Bittikohtaisesti TAI
Bituaalisesti yksinomainen TAI
Bittisuuntaiset operaattorit
Bittikohtainen operaattori

Bittikohtaisesti JA

Tämä on yksi yleisimmin käytetyistä loogisista bittinopeusoperaattoreista. Sitä edustaa yksi ampersandimerkki (&). (&) -Operaattorin molemmille puolille kirjoitetaan kaksi kokonaislukulauseketta.

Bittitason JA-toiminnan tulos on 1, jos molempien bittien arvo on 1; muuten tulos on aina 0.

Katsotaan, että meillä on 2 muuttujaa op1 ja op2, joiden arvot ovat seuraavat:

Op1 = 0000 1101Op2 = 0001 1001

Muuttujien op1 ja op2 AND-toiminnan tulos on

Result = 0000 1001

Kuten näemme, kahta muuttujaa verrataan vähitellen. Aina kun bitin arvo molemmissa muuttujissa on 1, tulos on 1 tai muuten 0.

Bittikohtaisesti TAI

Sitä edustaa yksi pystysuora palkkimerkki (|). Operaattorin (|) kummallekin puolelle kirjoitetaan kaksi kokonaislukulauseketta.

Bittikohtaisen TAI-operaation tulos on 1, jos ainakin yhden lausekkeen arvo on 1; muuten tulos on aina 0.

Katsotaan, että meillä on 2 muuttujaa op1 ja op2, joiden arvot ovat seuraavat:

Op1 = 0000 1101Op2 = 0001 1001

Muuttujien op1 ja op2 OR-operaation tulos on

Result = 0001 1101

Kuten näemme, kahta muuttujaa verrataan vähitellen. Aina kun jonkin muuttujan bitin arvo on 1, tulos on 1 tai muuten 0.

Bituaalisesti yksinomainen TAI

Sitä edustaa symboli (^). Operaattorin (^) kummallekin puolelle kirjoitetaan kaksi kokonaislukulauseketta.

Bittikohtaisesti Exclusive-OR -operaation tulos on 1, jos vain yhden lausekkeen arvo on 1; muuten tulos on aina 0.

Katsotaan, että meillä on 2 muuttujaa op1 ja op2, joiden arvot ovat seuraavat:

Op1 = 0000 1101Op2 = 0001 1001

Muuttujien op1 ja op2 OR-operaation tulos on

Result = 0001 0100

Kuten näemme, kahta muuttujaa verrataan vähitellen. Aina kun vain yhdellä muuttujalla on arvo 1, tulos on 0, muuten tulos on 0.

Kirjoitetaan yksinkertainen ohjelma, joka osoittaa bittinopeudella loogiset operaattorit.

#include int main(){int a = 20; /* 20 = 010100 */int b = 21; /* 21 = 010101 */int c = 0;c = a & b; /* 20 = 010100 */printf("AND - Value of c is %d\n", c );c = a | b; /* 21 = 010101 */printf("OR - Value of c is %d\n", c );c = a b; /* 1 = 0001 */printf("Exclusive-OR - Value of c is %d\n", c );getch();}

Tuotos:

AND - Value of c is 20OR - Value of c is 21Exclusive-OR - Value of c is 1

Bittisuuntaiset operaattorit

Bittisuuntaisen siirron operaattoreita käytetään siirtämään / siirtämään bittikuvioita joko vasemmalle tai oikealle puolelle. Vasen ja oikea ovat kaksi vuoronoperaattoria, jotka tarjoaa 'C' ja jotka esitetään seuraavasti:

Operand << n (Left Shift)Operand >> n (Right Shift)

Tässä,

operandi on kokonaislukulauseke, jolle meidän on suoritettava siirtotoiminto.
'n' on niiden bittipaikkojen kokonaismäärä, joita meidän on siirrettävä kokonaislausekkeessa.

Vasen siirtotoiminto siirtää n-bittimäärän vasemmalle puolelle. Lausekkeen vasemmanpuoleisin bitti ponnahtaa ulos ja n bittiä, jonka arvo on 0, täytetään oikealla puolella.

Oikea siirtotoiminto siirtää n-bittimäärän oikealle puolelle. Lausekkeen oikeanpuoleisimmat 'n' bitit ponnahtaa esiin, ja arvo 0 täytetään vasemmalla puolella.

Esimerkki: x on kokonaislukulauseke, joka sisältää datan 1111. Kun olet suorittanut siirtotoiminnon, tulos on:

x << 2 (left shift) = 1111<<2 = 1100x>>2 (right shift) = 1111>>2 = 0011

Vaihto-operaattorit voidaan yhdistää ja sitten sitä voidaan käyttää tietojen poimimiseen kokonaislausekkeesta. Kirjoitetaan ohjelma osoittamaan bittisiirtymäoperaattoreiden käyttöä.

#include int main() {int a = 20; /* 20 = 010100 */int c = 0;c = a << 2; /* 80 = 101000 */printf("Left shift - Value of c is %d\n", c );c = a >> 2; /*05 = 000101 */printf("Right shift - Value of c is %d\n", c );return 0;}

Tuotos:

Left shift - Value of c is 80Right shift - Value of c is 5

Vasemman siirtotoiminnon suorittamisen jälkeen arvosta tulee 80, jonka binaariekvivalentti on 101000.

Oikean siirtotoiminnon suorittamisen jälkeen arvosta tulee 5, jonka binaariekvivalentti on 000101.

Bittikohtainen operaattori

Bittikohtaista komplementtia kutsutaan myös yhden komplementtioperaattoriksi, koska se vie aina vain yhden arvon tai operandin. Se on unary operaattori.

Kun suoritamme täydennyksen mille tahansa bitille, kaikista 1: stä tulee 0 ja päinvastoin.

Jos meillä on kokonaislukulauseke, joka sisältää 0000 1111, suoritetaan bittikohtainen komplementtitoiminto arvosta 1111 0000.

Bittikohtainen komplementtioperaattori on merkitty symbolilla tilde (~).

Kirjoitetaan ohjelma, joka osoittaa bittiä täydentävän operaattorin toteutuksen.

#include int main() {int a = 10; /* 10 = 1010 */int c = 0;c = ~(a);printf("Complement - Value of c is %d\n", c );return 0;}

Tuotos:

Complement - Value of c is -11

Tässä on toinen ohjelma, jossa on esimerkki kaikista tähän mennessä keskustelluista oopperoista:

#include main() {unsigned int x = 48; /* 48 = 0011 0000 */unsigned int y = 13; /* 13 = 0000 1101 */int z = 0;z =x & y; /* 0 = 0000 0000 */printf("Bitwise AND Operator - x & y = %d\n", z );z = x | y; /* 61 = 0011 1101 */printf("Bitwise OR Operator - x | y = %d\n", z );z= x^y; /* 61 = 0011 1101 */printf("Bitwise XOR Operator- x^y= %d\n", z);z = ~x; /*-61 = 1100 0011 */printf("Bitwise One's Complement Operator - ~x = %d\n", z);z = x << 2; /* 192 = 1100 0000 */printf("Bitwise Left Shift Operator x << 2= %d\n", z );z= x >> 2; /* 12 = 0000 1100 */printf ("Bitwise Right Shift Operator x >> 2= %d\n", z );}

Kun olemme koonneet ja suorittaneet ohjelman, se tuottaa seuraavan tuloksen:

Bitwise AND Operator - x & y = 0Bitwise OR Operator - x | y = 61Bitwise XOR Operator- x^y= 61Bitwise One's Complement Operator - ~x = -49Bitwise Left Shift Operator x << 2= 192Bitwise Right Shift Operator x >> 2= 12