biteittäin Operatorit C:ssa: AND, OR, XOR, Shift & Täydentää

Mitä ovat Bitwise Operators?

biteittäin OperaOhjelmoinnissa käytetään datan käsittelyyn bittitasolla, jota kutsutaan myös bittitason ohjelmoinniksi. Bittikohtainen ohjelmointi käsittelee yhtä tai useampaa bittikuviota tai binäärinumeroa niiden yksittäisten bittien tasolla. Niitä käytetään numeerisissa laskennoissa laskentaprosessin nopeuttamiseksi.

Seuraavassa on luettelo C-ohjelmointikielen tarjoamista bittikohtaisista operaattoreista:

Bittikohtaisia ​​operaattoreita ei voida soveltaa suoraan alkeellisiin tietotyyppeihin, kuten float, double jne. Muista aina yksi asia, että bittikohtaisia ​​operaattoreita käytetään enimmäkseen kokonaislukutietotyyppi yhteensopivuutensa vuoksi.

Bittikohtaiset loogiset operaattorit käsittelevät dataa bitti kerrallaan alkaen vähiten merkitsevästä bitistä eli LSB-bitistä, joka on äärimmäisen oikealla oleva bitti, kohti MSB:tä (Most Significant Bit), joka on vasemmanpuoleisin bitti.

Bittikohtaisten loogisten operaattoreiden laskennan tulos on esitetty alla olevassa taulukossa.

Bittisesti JA

Tämä on yksi yleisimmin käytetyistä loogisista bittikohtaisista operaattoreista. Sitä edustaa yksi et-merkki (&). Kaksi kokonaislukulauseketta kirjoitetaan (&)-operaattorin kummallekin puolelle.
Bittikohtaisen JA-operaation tulos on 1, jos molempien bittien arvo on 1; muuten tulos on aina 0.

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

Op1 = 0000 1101
Op2 = 0001 1001

AND-operaation tulos muuttujilla op1 ja op2 on

Result = 0000 1001

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

Bittaisesti TAI

Sitä edustaa yksi pystysuora palkkimerkki (|). Kaksi kokonaislukulauseketta kirjoitetaan operaattorin (|) molemmille puolille.

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

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

Op1 = 0000 1101
Op2 = 0001 1001

TAI-operaation tulos muuttujilla op1 ja op2 on

Result = 0001 1101

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

Bitwise Exclusive TAI

Sitä edustaa symboli (^). Kaksi kokonaislukulauseketta kirjoitetaan operaattorin (^) molemmille puolille.

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

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

Op1 = 0000 1101
Op2 = 0001 1001

XOR-operaation tulos muuttujilla op1 ja op2 on

Result = 0001 0100

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

Kirjoitetaan yksinkertainen ohjelma, joka esittää bittikohtaisia ​​loogisia operaattoreita.

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

lähtö:

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

Bittisiirtooperaattorit

Bittikohtaisia ​​siirto-operaattoreita käytetään bittikuvioiden siirtämiseen joko vasemmalle tai oikealle. Vasen ja oikea ovat kaksi siirto-operaattoria, jotka 'C' antaa ja joita esitetään seuraavasti:

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

Täällä

• operandi on kokonaislukulauseke, jolle meidän on suoritettava siirtotoiminto.
• 'n' on niiden bittipaikkojen kokonaismäärä, jotka meidän on siirrettävä kokonaislukulausekkeessa.

Vasemmanpuoleinen siirtotoiminto siirtää "n" bittien määrän vasemmalle puolelle. Lausekkeen vasemmanpuoleisin bitti ponnahtaa esiin ja n bittiä, joiden arvo on 0, täytetään oikealla puolella.

Oikea siirtotoiminto siirtää 'n' bittien määrän oikealle puolelle. Lausekkeen oikeanpuoleisin 'n'-bitti ponnahtaa esiin, ja arvo 0 täytetään vasemmalla puolella.

Esimerkki: x on kokonaislukulauseke, jonka data on 1111. Siirtotoiminnon suorittamisen jälkeen tulos on:

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

Shifts-operaattoreita voidaan yhdistää, jolloin sitä voidaan käyttää esimerkiksitract kokonaislukulausekkeen tiedot. Kirjoitetaan ohjelma, joka demonstroi bittikohtaisten siirto-operaattoreiden käyttöä.

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

lähtö:

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

Vasemman siirtotoiminnon suorittamisen jälkeen arvoksi tulee 80, jonka binäärivastine on 101000.

Oikean siirtotoiminnon suorittamisen jälkeen arvoksi tulee 5, jonka binäärivastine on 000101.

Bittikomplementtioperaattori

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

Kun suoritamme komplementin mille tahansa bitille, kaikista ykkösistä tulee nollia ja päinvastoin.

Jos meillä on kokonaislukulauseke, joka sisältää 0000 1111, bittikohtaisen komplementtioperaation suorittamisen jälkeen arvoksi tulee 1111 0000.

Bittikomplementtioperaattori on merkitty symbolilla tilde (~).

Kirjoitetaan ohjelma, joka esittelee bittikohtaisen komplementtioperaattorin toteutusta.

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

lähtö:

Complement - Value of c is -11

Tässä on toinen ohjelma, jossa on esimerkki kaikista tähän mennessä käsitellyistä operaattoreista:

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

Kun olemme kääntäneet ja suorittaneet ohjelman, se tuottaa seuraavan tuloksen:

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

UKK