Bituumen Operatorsid C-s: JA, VÕI, XOR, Shift & Täiendada

Järgmine on programmeerimiskeele C pakutavate bitioperaatorite loend:

Operator	Tähendus
&	Bitipõhine JA operaator
|	Bitipõhine VÕI operaator
^	Bitipõhine eksklusiivne VÕI-operaator
~	Binaarse ühe komplement Operator on ühekordne operaator
<<	Vasakpoolse vahetuse operaator
>>	Parema vahetuse operaator

Bitioperaatoreid ei saa otse rakendada primitiivsetele andmetüüpidele, nagu float, double jne. Pidage alati meeles üht asja, et bitipõhiseid operaatoreid kasutatakse selle ühilduvuse tõttu enamasti täisarvulise andmetüübiga.

Bitipõhised loogilised operaatorid töötavad andmete kallal bittide kaupa, alustades kõige vähemtähtsast bitist, st LSB-bitist, mis on kõige parempoolsem bit, liikudes MSB (Most Significant Bit) poole, mis on kõige vasakpoolsem bitt.

Bitipõhiste loogiliste operaatorite arvutamise tulemus on näidatud allolevas tabelis.

x	y	x & y	x | seal	x^y
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

Pikkade kaupa JA

See on üks kõige sagedamini kasutatavaid loogilisi bitipõhiseid operaatoreid. Seda tähistab üks ampersand (&). Operaatori (&) mõlemale küljele kirjutatakse kaks täisarvulist avaldist.
Bitipõhise JA-operatsiooni tulemus on 1, kui mõlema biti väärtus on 1; vastasel juhul on tulemus alati 0.

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

Op1 = 0000 1101
Op2 = 0001 1001

Muutujate op1 ja op2 AND-operatsiooni tulemus on

Result = 0000 1001

Nagu näeme, võrreldakse kahte muutujat bittide kaupa. Kui biti väärtus mõlemas muutujas on 1, on tulemuseks 1 või 0.

Pikkade kaupa VÕI

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

Bitipõhise VÕI-toimingu tulemus on 1, kui vähemalt ühe avaldise väärtus on 1; muidu on tulemus alati 0.

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

Op1 = 0000 1101
Op2 = 0001 1001

VÕI-toimingu tulemus muutujatel op1 ja op2 on

Result = 0001 1101

Nagu näeme, võrreldakse kahte muutujat bittide kaupa. Kui mõne muutuja biti väärtus on 1, on tulemuseks 1 või 0.

Bitipõhine eksklusiivne VÕI

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

Bitipõhise Exclusive-OR-operatsiooni tulemus on 1, kui ainult ühe avaldise väärtus on 1; muidu on tulemus alati 0.

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

Op1 = 0000 1101
Op2 = 0001 1001

XOR-operatsiooni tulemus muutujatel op1 ja op2 on

Result = 0001 0100

Nagu näeme, võrreldakse kahte muutujat bittide kaupa. Kui ainult ühel muutujal on väärtus 1, on tulemuseks 0, muidu on tulemuseks 0.

Kirjutame lihtsa programmi, mis demonstreerib bitipõhiseid loogilisi operaatoreid.

#include <stdio.h>
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 20
OR - Value of c is 21
Exclusive-OR - Value of c is 1

Bitinihke operaatorid

Bitipõhise nihke operaatoreid kasutatakse bitimustrite liigutamiseks/nihutamiseks kas vasakule või paremale poole. Vasak ja parem on kaks vahetusoperaatorit, mille pakubC", mis on esitatud järgmiselt:

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

Siin

• operaand on täisarvuline avaldis, millel peame sooritama nihkeoperatsiooni.
• 'n' on bitipositsioonide koguarv, mida peame täisarvuavaldises nihutama.

Vasakpoolse nihutamise operatsioon nihutab "n" bittide arvu vasakule poole. Avaldise vasakpoolseimad bitid hüppatakse välja ja n bitti väärtusega 0 täidetakse paremal pool.

Parempoolse nihutamise operatsioon nihutab 'n' bittide arvu paremale poole. Avaldise kõige parempoolsemad n-bitid hüppatakse välja ja väärtus 0 täidetakse vasakul pool.

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

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

Shifts operaatoreid saab kombineerida, siis saab seda kasutada andmete eraldamiseks täisarvu avaldisest. Kirjutame programmi, mis demonstreerib bitipõhise nihke operaatorite kasutamist.

#include <stdio.h>
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 80
Right shift - Value of c is 5

Pärast vasakpoolse nihutamise toimingu sooritamist saab väärtuseks 80, mille binaarne ekvivalent on 101000.

Pärast parempoolse nihutamise toimingu sooritamist muutub väärtuseks 5, mille binaarne ekvivalent on 000101.

Bititäienduse operaator

Bitilist komplementi nimetatakse ka komplemendi operaatoriks, kuna see võtab alati ainult ühe väärtuse või operandi. See on ühekordne operaator.

Kui teostame suvalise bitti täienduse, muutuvad kõik 1-d 0-deks ja vastupidi.

Kui meil on täisarvuline avaldis, mis sisaldab 0000 1111, siis pärast bitipõhise komplemendi toimingu sooritamist muutub väärtuseks 1111 0000.

Bititäienduse operaator on tähistatud sümboliga tilde (~).

Kirjutame programmi, mis demonstreerib bitipõhise komplemendi operaatori rakendamist.

#include <stdio.h>
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 näitega kõigist seni arutatud operaatidest:

#include <stdio.h>
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;          /*-49 = 11001111 */
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 = 0
Bitwise OR Operator - x | y = 61
Bitwise XOR Operator- x^y= 61
Bitwise One's Complement Operator - ~x = -49
Bitwise Left Shift Operator x << 2= 192
Bitwise Right Shift Operator x >> 2= 12

kokkuvõte

• Bitioperaatorid on spetsiaalne operaatorite komplekt, mille pakub 'C.'
• Neid kasutatakse bititaseme programmeerimisel.
• Neid operaatoreid kasutatakse täisarvulise avaldise bittide manipuleerimiseks.
• Loogiline, nihe ja komplement on kolme tüüpi bitipõhised operaatorid.
• Bititäienduse operaatorit kasutatakse avaldise bittide ümberpööramiseks.