bitenkénti Operatorok C-ben: ÉS, VAGY, XOR, Shift & Kiegészítés

Az alábbiakban a 'C' programozási nyelv által biztosított bitenkénti operátorok listája található:

Operator	Jelentés
&	Bitenkénti ÉS operátor
|	Bitenkénti VAGY operátor
^	Bitenkénti kizárólagos VAGY operátor
~	A bináris egyes komplementere OperaA tor egy unáris operátor
<<	Bal váltókezelő
>>	Jobb váltókezelő

A bitenkénti operátorokat nem lehet közvetlenül alkalmazni olyan primitív adattípusokra, mint a float, double stb. Mindig ne feledjen egy dolgot, hogy a bitenkénti operátorokat többnyire az egész adattípussal együtt használják, annak kompatibilitása miatt.

A bitenkénti logikai operátorok bitenként dolgoznak az adatokon, kezdve a legkisebb jelentőségű bittől, azaz az LSB bittől, amely a jobb szélső bit, és az MSB (Most Significant Bit) felé haladva, amely a bal szélső bit.

A bitenkénti logikai operátorok számításának eredményét az alábbi táblázat mutatja.

x	y	x & y	x | és	x^y
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

Bitálisan ÉS

Ez az egyik leggyakrabban használt logikai bitenkénti operátor. Ezt egyetlen „és” jel (&) jelöli. Két egész kifejezést írunk az (&) operátor mindkét oldalára.
A bitenkénti ÉS művelet eredménye 1, ha mindkét bit értéke 1; egyébként az eredmény mindig 0.

Tekintsük, hogy van 2 op1 és op2 változónk a következő értékekkel:

Op1 = 0000 1101
Op2 = 0001 1001

Az AND művelet eredménye az op1 és op2 változókon lesz

Result = 0000 1001

Amint látjuk, két változót bitenként hasonlítanak össze. Ha a bit értéke mindkét változóban 1, akkor az eredmény 1 vagy 0 lesz.

Bitenként VAGY

Egyetlen függőleges oszlopjel (|) ábrázolja. Két egész kifejezést írunk a (|) operátor mindkét oldalára.

A bitenkénti VAGY művelet eredménye 1, ha legalább az egyik kifejezés értéke 1; egyébként az eredmény mindig 0.

Tekintsük, hogy van 2 op1 és op2 változónk a következő értékekkel:

Op1 = 0000 1101
Op2 = 0001 1001

Az op1 és op2 változókra vonatkozó VAGY művelet eredménye a következő lesz

Result = 0001 1101

Amint látjuk, két változót bitenként hasonlítanak össze. Ha az egyik változóban egy bit értéke 1, akkor az eredmény 1 vagy 0 lesz.

Bitenkénti exkluzív VAGY

Egy szimbólum (^) jelöli. Két egész kifejezést írunk a (^) operátor mindkét oldalára.

A bitenkénti Exclusive-OR művelet eredménye 1, ha csak az egyik kifejezés értéke 1; egyébként az eredmény mindig 0.

Tekintsük, hogy van 2 op1 és op2 változónk a következő értékekkel:

Op1 = 0000 1101
Op2 = 0001 1001

Az XOR művelet eredménye az op1 és op2 változókon lesz

Result = 0001 0100

Amint látjuk, két változót bitenként hasonlítanak össze. Ha csak egy változóban van 1, akkor az eredmény 0, különben 0 lesz az eredmény.

Írjunk egy egyszerű programot, amely bitenkénti logikai operátorokat mutat be.

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

output:

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

Bitenkénti eltolási operátorok

A bitenkénti eltolási operátorok a bitminták balra vagy jobbra történő mozgatására/eltolására szolgálnak. A bal és a jobb oldal két műszak operátort biztosít a 'C", amelyek a következőképpen vannak ábrázolva:

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

Itt,

• az operandus egy egész kifejezés, amelyen el kell végeznünk a shift műveletet.
• Az 'n' azoknak a bithelyeknek a száma, amelyeket el kell tolnunk az egész kifejezésben.

A bal oldali eltolás művelet az 'n' számú bitet a bal oldalra tolja. A kifejezés bal szélső bitjei kiugrik, és n bit 0 értékű a jobb oldalon.

A jobb oldali eltolás művelet az 'n' számú bitet a jobb oldalra tolja. A kifejezés jobb szélső 'n' bitjei kiugrik, és a 0 érték a bal oldalon lesz kitöltve.

Példa: x egy egész kifejezés 1111 adattal. A shift művelet végrehajtása után az eredmény a következő lesz:

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

Shifts operátorok kombinálhatók, akkor az adatok kinyerésére használhatók az egész kifejezésből. Írjunk egy programot a bitenkénti eltolási operátorok használatának bemutatására.

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

output:

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

A balra eltolás művelet végrehajtása után az érték 80 lesz, melynek bináris megfelelője 101000.

A jobb eltolási művelet végrehajtása után az érték 5 lesz, amelynek bináris megfelelője 000101.

Bitenkénti komplement operátor

A bitenkénti kiegészítést komplement operátornak is nevezik, mivel mindig csak egy értéket vagy egy operandust vesz fel. Ez egy unáris operátor.

Ha bármely biten komplementet hajtunk végre, az 1-esek 0-vá válnak, és fordítva.

Ha van egy egész kifejezésünk, amely 0000 1111-et tartalmaz, akkor bitenkénti komplementművelet végrehajtása után az érték 1111 0000 lesz.

A bitenkénti komplement operátort tilde (~) szimbólum jelöli.

Írjunk egy programot, amely bemutatja a bitenkénti komplement operátor megvalósítását.

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

output:

Complement - Value of c is -11

Íme egy másik program, egy példával az összes eddig tárgyalt operációra:

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

A program összeállítása és futtatása után a következő eredményt adja:

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

Összegzésként

• A bitenkénti operátorok a 'C' által biztosított speciális operátorkészletek.
• Bitszintű programozásban használatosak.
• Ezeket az operátorokat egy egész kifejezés bitjeinek manipulálására használják.
• A logikai, a shift és a komplementer háromféle bitenkénti operátor.
• A bitenkénti komplement operátor a kifejezés bitjeinek megfordítására szolgál.