C Operaatorid bitipidi: AND, OR, XOR, Shift & Täiendus (koos näitega)

Mis on Bitwise operaatorid?

BITWISE OPERATORS kasutatakse andmete töötlemiseks bititasemel , mida nimetatakse ka bititaseme programmeerimiseks. Bitipõhiselt töötab üks või mitu bittmustrit või kahendnumbrit nende üksikute bittide tasemel. Arvutusprotsessi kiirendamiseks kasutatakse neid arvulistes arvutustes.

Järgmine on loend bitipõhistest operaatoritest, mille pakub programmeerimiskeel „C”:

Operaator	Tähendus
&	Pikkade kaupa JA operaator
\|	Biti kaupa VÕI operaator
^	Bitipõhine eksklusiivne VÕI operaator
~	Binaarse üksuse täiendusoperaator on unaarne operaator
<<	Vasaku vahetuse operaator
>>	Parema vahetuse operaator

Bitipõhiseid operaatoreid ei saa otseselt rakendada primitiivsetele andmetüüpidele, näiteks ujuk, kahekordne jne. Pidage alati meeles ühte asja, et bittide kaupa operaatoreid kasutatakse enamasti täisarvu andmetüüpidega selle ühilduvuse tõttu.

Biti kaupa töötavad loogilised operaatorid töötavad andmete kallal, alustades kõige vähemtähtsast bitist, st LSB-bitist, mis on kõige parem bit, liikudes kõige vasakpoolsema bitiga MSB (Most Significant Bit) poole.

Biti kaupa loogiliste operaatorite arvutamise tulemus on toodud allpool toodud tabelis.

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

Selles õpetuses saate teada

Mis on Bitwise operaatorid?
Pikkade kaupa JA
Pikkade kaupa VÕI
Bititi eksklusiivne VÕI
Pikkade vahetustega operaatorid
Täiendav operaator bititi

Pikkade kaupa JA

See on üks levinumaid loogilisi bitipõhiseid operaatoreid. Seda tähistab üks tähemärk (&). Operaatori (&) mõlemale küljele kirjutatakse kaks täisarvulist avaldist.

Jaotise JA tulemus on 1, kui mõlema biti väärtus on 1; muidu on tulemus alati 0.

Mõelgem, et meil on 2 muutujat op1 ja op2, mille väärtused on järgmised:

Op1 = 0000 1101Op2 = 0001 1001

Muutujate op1 ja op2 AND operatsiooni tulemus on

Result = 0000 1001

Nagu näeme, võrreldakse järk-järgult kahte muutujat. Kui mõlema muutuja biti väärtus on 1, on tulemus 1 või muidu 0.

Pikkade kaupa VÕI

Seda tähistab üks vertikaalse riba märk (|). Operaatori (|) mõlemale küljele kirjutatakse kaks täisarvulist avaldist.

Biti OR operatsiooni tulemus on 1, kui vähemalt ühe avaldise väärtus on 1; muidu on tulemus alati 0.

Mõelgem, et meil on 2 muutujat op1 ja op2, mille väärtused on järgmised:

Op1 = 0000 1101Op2 = 0001 1001

Muutujate op1 ja op2 OR operatsiooni tulemus on

Result = 0001 1101

Nagu näeme, võrreldakse järk-järgult kahte muutujat. Alati, kui ühe muutuja biti väärtus on 1, on tulemus 1 või muidu 0.

Bititi eksklusiivne VÕI

Seda tähistab sümbol (^). Operaatori (^) mõlemale küljele kirjutatakse kaks täisarvulist avaldist.

Operatsiooni bititi Exclusive-OR tulemus on 1, kui ainult ühe avaldise väärtus on 1; muidu on tulemus alati 0.

Mõelgem, et meil on 2 muutujat op1 ja op2, mille väärtused on järgmised:

Op1 = 0000 1101Op2 = 0001 1001

Muutujate op1 ja op2 OR operatsiooni tulemus on

Result = 0001 0100

Nagu näeme, võrreldakse järk-järgult kahte muutujat. Kui ainult üks muutuja omab väärtust 1, on tulemus 0, siis on tulemuseks 0.

Kirjutagem lihtne programm, mis demonstreerib bitipõhiseid loogikaoperaatoreid.

#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();}

Väljund:

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

Pikkade vahetustega operaatorid

Pikkade nihkeoperaatoreid kasutatakse bitimustrite teisaldamiseks / nihutamiseks kas vasakule või paremale küljele. Vasakul ja paremal on kaks C-tähega vahetuseoperaatorit, mis on esitatud järgmiselt:

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

Siin,

operand on täisarvuline avaldis, millele peame tegema nihkeoperatsiooni.
'n' on bittide koguarv, mida peame täisarvulises avaldises nihutama.

Vasakul nihutamisel nihutatakse bittide arv vasakule küljele. Avaldise kõige vasakpoolsemad bitid hüpatakse välja ja paremal küljel täidetakse n bitti väärtusega 0.

Parema nihke korral nihutatakse bittide arv paremale küljele. Avaldise parempoolseimad 'n' bitid hüpatakse välja ja väärtus 0 täidetakse vasakul küljel.

Näide: x on täisarvuline avaldis andmetega 1111. Pärast nihketoimingu tegemist on tulemus:

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

Nihkeoperaatoreid saab kombineerida, seejärel saab seda kasutada andmete eraldamiseks täisarvulausest. Kirjutagem programm, et demonstreerida bitti vahetavate operaatorite kasutamist.

#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;}

Väljund:

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

Pärast vasakpoolse nihke toimingut saab väärtuseks 80, mille binaarekvivalent on 101000.

Pärast parema vahetuse toimingu tegemist saab väärtuseks 5, mille binaarekvivalent on 000101.

Täiendav operaator bititi

Biti kaupa täiendit nimetatakse ka oma täiendusoperaatoriks, kuna see võtab alati ainult ühe väärtuse või operandi. See on unaarne operaator.

Kui täidame mis tahes bitti komplemendi, muutuvad kõik 1-d 0-ks ja vastupidi.

Kui meil on täisarvuline avaldis, mis sisaldab 0000 1111, siis pärast komplitseeritava bitipidi toimingu tegemist saab väärtuseks 1111 0000.

Biti kaupa täiendusoperaatorit tähistatakse sümboliga tilde (~).

Kirjutagem programm, mis demonstreerib bitipõhise täiendusoperaatori rakendamist.

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

Väljund:

Complement - Value of c is -11

Siin on veel üks programm koos kõigi seni arutatud ooperite näidetega:

#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 );}

Pärast programmi kompileerimist ja käivitamist annab see järgmise tulemuse:

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