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

Mis on Bitwise Operators?

Bituumen OperaToreid kasutatakse andmete manipuleerimiseks bititasemel, mida nimetatakse ka bititaseme programmeerimiseks. Bitipõhine programmeerimine töötab ühe või mitme bitimustri või binaararvuga nende üksikute bittide tasandil. Neid kasutatakse numbrilistes arvutustes arvutusprotsessi kiirendamiseks.

Järgmine on programmeerimiskeele C pakutavate bitioperaatorite loend:

Bitipõhiseid operaatoreid ei saa otse rakendada primitiivsetele andmetüüpidele nagu float, double jne. Pidage alati meeles, et bitipõhiseid operaatoreid kasutatakse enamasti koos täisarvu andmetüüp oma ühilduvuse tõttu.

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.

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õhiste nihutamisoperaatorite abil saab bitimustreid vasakule või paremale nihutada. Vasakule ja paremale on kaks nihutamisoperaatorit, mida annab 'C' ja mida esitatakse 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 näitekstract täisarvulise avaldise andmed. Kirjutame programmi, mis demonstreerib bitipõhiste nihutusoperaatorite 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äidetega kõigist seni käsitletud operaatoritest:

#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

KKK