Ebben az oktatóanyagban példákkal megismerheti a C programozás mind a 6 bitenkénti operátorát.
Az aritmetikai-logikai egységben (amely a CPU-n belül van) az olyan matematikai műveletek, mint: összeadás, kivonás, szorzás és osztás bit-szinten történnek. A bitszintű műveletek végrehajtásához C programozásban bitenként operátorokat használnak.
| Operátorok | Az operátorok jelentése |
|---|---|
| & | Bitenkénti ÉS |
| | | Bitenként VAGY |
| ^ | Bitenként XOR |
| ~ | Bitenkénti kiegészítés |
| << | Váltás balra |
| >> | Váltás jobbra |
Bitenkénti ÉS operátor &
Az AND bitenkénti kimenete 1, ha két operandus megfelelő bitje 1. Ha egy operandus bármelyik bitje 0, akkor a megfelelő bit eredményét 0-ra értékeljük.
Tegyük fel, hogy két egész 12 és 25 bit bitenkénti művelete van.
12 = 00001100 (bináris formátumban) 25 = 00011001 (bináris formátumban) 12 és 25 bitműveletek 00001100 és 00011001 ________ 00001000 = 8 (tizedesjegyben)
1. példa: Bitenkénti ÉS
#include int main() ( int a = 12, b = 25; printf("Output = %d", a&b); return 0; )
Kimenet
Kimenet = 8
Bitenkénti VAGY operátor |
A bitenkénti OR kimenete 1, ha két operandus legalább egy megfelelő bitje 1. A C programozásban a bitenként OR operátort |
12 = 00001100 (bináris formátumban) 25 = 00011001 (bináris formátumban) bitenkénti VAGY a 12 és a 25 művelete 00001100 | 00011001 ________ 00011101 = 29 (tizedesjegyben)
2. példa: Bitenként vagy VAGY
#include int main() ( int a = 12, b = 25; printf("Output = %d", a|b); return 0; )
Kimenet
Kimenet = 29
Bitenként XOR (kizárólagos VAGY) operátor ^
A bitenkénti XOR operátor eredménye 1, ha két operandus megfelelő bitjei ellentétesek. Jelöli.
12 = 00001100 (bináris formában) 25 = 00011001 (bináris formátumban) A 12 és 25 bitenkénti XOR-művelete 00001100 00011001 ________ 00010101 = 21 (tizedesjegyben)
3. példa: Bitenként XOR
#include int main() ( int a = 12, b = 25; printf("Output = %d", a^b); return 0; )
Kimenet
Kimenet = 21
Bitenkénti komplementer operátor ~
A bitenkénti bók operátor unáriás operátor (csak egy operanduson működik). 1-ről 0-ra és 0-ról 1-re változik. Ezt ~ jelöli.
35 = 00100011 (bináris formában) Komplett művelet a 35 ~ 00100011 művelethez
Csavarja be a bitenkénti komplementer operátort a C programozásban
A 35 (~ 35) bitenkénti kiegészítése 220 helyett -36, de miért?
Bármely n egész szám esetén n bitjének bitenkénti kiegészítése lesz -(n+1). Ennek megértéséhez ismernie kell a 2-es kiegészítést.
2. kiegészítése
Two's complement is an operation on binary numbers. The 2's complement of a number is equal to the complement of that number plus 1. For example:
Decimal Binary 2's complement 0 00000000 -(11111111+1) = -00000000 = -0(decimal) 1 00000001 -(11111110+1) = -11111111 = -256(decimal) 12 00001100 -(11110011+1) = -11110100 = -244(decimal) 220 11011100 -(00100011+1) = -00100100 = -36(decimal) Note: Overflow is ignored while computing 2's complement.
The bitwise complement of 35 is 220 (in decimal). The 2's complement of 220 is -36. Hence, the output is -36 instead of 220.
Bitwise complement of any number N is -(N+1). Here's how:
bitwise complement of N = ~N (represented in 2's complement form) 2'complement of ~N= -(~(~N)+1) = -(N+1)
Example #4: Bitwise complement
#include int main() ( printf("Output = %d",~35); printf("Output = %d",~-12); return 0; )
Output
Output = -36 Output = 11
Shift Operators in C programming
There are two shift operators in C programming:
- Right shift operator
- Left shift operator.
Right Shift Operator
Right shift operator shifts all bits towards right by certain number of specified bits. It is denoted by>>.
212 = 11010100 (In binary) 212>>2 = 00110101 (In binary) (Right shift by two bits) 212>>7 = 00000001 (In binary) 212>>8 = 00000000 212>>0 = 11010100 (No Shift)
Left Shift Operator
Left shift operator shifts all bits towards left by a certain number of specified bits. The bit positions that have been vacated by the left shift operator are filled with 0. The symbol of the left shift operator is <<.
212 = 11010100 (In binary) 212<<1 = 110101000 (In binary) (Left shift by one bit) 212<<0 = 11010100 (Shift by 0) 212<<4 = 110101000000 (In binary) =3392(In decimal)
Example #5: Shift Operators
#include int main() ( int num=212, i; for (i=0; i>i); printf(""); for (i=0; i<=2; ++i) printf("Left shift by %d: %d", i, num<
Right Shift by 0: 212 Right Shift by 1: 106 Right Shift by 2: 53 Left Shift by 0: 212 Left Shift by 1: 424 Left Shift by 2: 848
