U ovom uputstvu naučit ćemo o bitnim operatorima u C ++ uz pomoć primjera.
U C ++-u bitni operatori izvode operacije nad cjelobrojnim podacima na pojedinačnoj razini bita. Te operacije uključuju ispitivanje, postavljanje ili pomicanje stvarnih bitova. Na primjer,
a & b; a | b;
Evo popisa 6 bitnih operatora uključenih u C ++.
| Operater | Opis |
|---|---|
& | Bit-bit i operator |
| | Bitno ILI operator |
^ | Bitno XOR operator |
~ | Operator dodataka u bitovima |
<< | Pomicanje ulijevo ulijevo |
>> | Pomicanje udesno operatora |
Ti su operateri neophodni jer aritmetičko-logička jedinica (ALU) prisutna u CPU računala izvodi aritmetičke operacije na razini bitova.
Napomena: Bitno operatori mogu se koristiti samo uz charte intvrste podataka.
1. C ++ bitni i operator
U bitovima I & operator vraća 1 ako i samo ako su oba operanda su 1 . U suprotnom, vraća 0 .
Sljedeća tablica prikazuje rad bitnog operatora AND . Neka su a i b dva operanda koja mogu poprimiti samo binarne vrijednosti, tj. 1 i 0 .
| a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Napomena: Gornja tablica poznata je kao "tablica istine" za bitni operater AND .
Pogledajmo bitni I rad dviju cijelih 12 i 25:
12 = 00001100 (u binarnom) 25 = 00011001 (u binarnom) // Bitno I rad 12 i 25 00001100 & 00011001 _________ 00001000 = 8 (u decimalnom)
Primjer 1: Bitno I
#include using namespace std; int main() ( // declare variables int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a & b = " << (a & b) << endl; return 0; )
Izlaz
a = 12 b = 25 a & b = 8
U gornjem primjeru deklarirali smo dvije varijable a i b. Evo, primijetite crtu,
cout << "a & b = " << (a & b) << endl;
Ovdje izvodimo bitni I između varijabli a i b.
2. C ++ bitovni ILI operator
U bitovni OR | operator vraća 1 ako je barem jedan od operanada je 1 . U suprotnom, vraća 0 .
Sljedeća tablica istine prikazuje rad bitnog ILI operatora. Neka su a i b dva operanda koja mogu poprimiti samo binarne vrijednosti, tj. 1 ili 0 .
| a | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Pogledajmo bitovnu ILI operaciju dviju cijelih brojeva 12 i 25 :
12 = 00001100 (u binarnom) 25 = 00011001 (u binarnom) Bitno ILI rad 12 i 25 00001100 | 00011001 _________ 00011101 = 29 (u decimalu)
Primjer 2: Bitno ILI
#include int main() ( int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a | b = " << (a | b) << endl; return 0; )
Izlaz
a = 12 b = 25 a | b = 29
Bitovni OR od a = 12i b = 25daje 29.
3. C ++ bitni XOR operator
Bitovima XOR ^ operator vraća 1 ako i samo ako je jedan od operanada je 1 . Međutim, ako su oba operanda 0 ili ako su oba 1 , tada je rezultat 0 .
Sljedeća tablica istine prikazuje rad bitnog XOR operatora. Neka su a i b dva operanda koja mogu poprimiti samo binarne vrijednosti, tj. 1 ili 0 .
| a | b | a b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Pogledajmo bitovni XOR rad dviju cijelih brojeva 12 i 25:
12 = 00001100 (u binarnom) 25 = 00011001 (u binarnom) Bitno XOR rad 12 i 25 00001100 00011001 _________ 00010101 = 21 (u decimalnom)
Primjer 3: Bitni XOR
#include int main() ( int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a b = " << (a b) << endl; return 0; )
Izlaz
a = 12 b = 25 a b = 21
Bitovima XOR od a = 12i b = 25daje 21.
4. C ++ bitovni operater komplementa
Operator bitnog komplementa je unarni operator (radi na samo jednom operandu). Označava se time ~što mijenja binarne znamenke 1 na 0 i 0 na 1 .
Bitni dodatak
Važno je napomenuti da je bitni komplement bilo kojeg cjelobrojnog N jednak - (N + 1) . Na primjer,
Razmotrimo cijeli broj 35 . Prema pravilu, bitni dodatak od 35 trebao bi biti - (35 + 1) = -36 . Sad, da vidimo hoćemo li dobiti točan odgovor ili ne.
35 = 00100011 (In Binary) // Using bitwise complement operator ~ 00100011 __________ 11011100
In the above example, we get that the bitwise complement of 00100011 (35) is 11011100. Here, if we convert the result into decimal we get 220.
However, it is important to note that we cannot directly convert the result into decimal and get the desired output. This is because the binary result 11011100 is also equivalent to -36.
To understand this we first need to calculate the binary output of -36. We use 2's complement to calculate the binary of negative integers.
2's Complement
The 2's complement of a number N gives -N.
In binary arithmetic, 1's complement changes 0 to 1 and 1 to 0.
And, if we add 1 to the result of the 1's complement, we get the 2's complement of the original number.
For example,
36 = 00100100 (In Binary) 1's Complement = 11011011 2's Complement : 11011011 + 1 _________ 11011100
Here, we can see the 2's complement of 36 (i.e. -36) is 11011100. This value is equivalent to the bitwise complement of 35 that we have calculated in the previous section.
Hence, we can say that the bitwise complement of 35 = -36.
Example 4: Bitwise Complement
#include int main() ( int num1 = 35; int num2 = -150; cout << "~(" << num1 << ") = " << (~num1) << endl; cout << "~(" << num2 << ") = " << (~num2) << endl; return 0; )
Output
~(35) = -36 ~(-150) = 149
In the above example, we declared two integer variables num1 and num2, and initialized them with the values of 35 and -150 respectively.
We then computed their bitwise complement with the codes (~num1) and (~num2) respectively and displayed them on the screen.
The bitwise complement of 35 = - (35 + 1) = -36 i.e. ~35 = -36 The bitwise complement of -150 = - (-150 + 1) = - (-149) = 149 i.e. ~(-150) = 149
This is exactly what we got in the output.
C++ Shift Operators
There are two shift operators in C++ programming:
- Right shift operator
>> - Left shift operator
<<
5. C++ Right Shift Operator
The right shift operator shifts all bits towards the right by a certain number of specified bits. It is denoted by >>.
Kada pomaknemo bilo koji broj udesno, najmanje značajni bitovi se odbacuju, dok se najznačajniji bitovi zamjenjuju nulama.
jedan pomak udesno
Kao što vidimo sa gornje slike, imamo 4-bitni broj . Kada smo izvršili jednu bitnu operaciju desni pomak na njemu, svaki pojedinac malo je pomaknut u desno za 1 bit.
Kao rezultat, krajnji desni bit se odbacuje, dok krajnji lijevi bit ostaje prazan. Ovo je slobodno mjesto zamijenjeno s 0 .
6. C ++ Operator lijevog pomaka
Lijevi operater pomak pomiče sve bitove na lijevoj određeni broj navedenih bitova . Označava se sa <<.
jedan bit Lijevi Shift
As we can see from the image above, we have a 4-bit number. When we perform a 1 bit left shift operation on it, each individual bit is shifted to the left by 1 bit.
As a result, the left-most bit is discarded, while the right-most bit remains vacant. This vacancy is replaced by a 0.
Example 5: Shift Operators
#include int main() ( // declaring two integer variables int num = 212, i; // Shift Right Operation cout << "Shift Right:" << endl; // Using for loop for shifting num right from 0 bit to 3 bits for (i = 0; i < 4; i++) ( cout <> " << i << " = " <> i) << endl; ) // Shift Left Operation cout << "Shift Left:" << endl; // Using for loop for shifting num left from 0 bit to 3 bits for (i = 0; i < 4; i++) ( cout << "212 << " << i << " = " << (212 << i) << endl; ) return 0; )
Output
Shift Right: 212>> 0 = 212 212>> 1 = 106 212>> 2 = 53 212>> 3 = 26 Shift Left: 212 << 0 = 212 212 << 1 = 424 212 << 2 = 848 212 << 3 = 1696
From the output of the program above, we can infer that, for any number N, the results of the shift right operator are:
N>> 0 = N N>> 1 = (N>> 0) / 2 N>> 2 = (N>> 1) / 2 N>> 3 = (N>> 2) / 2
and so on.
Similarly, the results of the shift left operator are:
N << 0 = N N << 1 = (N << 0) * 2 N << 2 = (N << 1) * 2 N << 3 = (N << 2) * 2
and so on.
Hence we can conclude that,
N>> m = ( N>> (m-1) ) / 2 N << m = ( N << (m-1) ) * 2
In the above example, note that the int data type stores numbers in 32-bits i.e. an int value is represented by 32 binary digits.
However, our explanation for the bitwise shift operators used numbers represented in 4-bits.
For example, the base-10 number 13 can be represented in 4-bit and 32-bit as:
4-bit Representation of 13 = 1101 32-bit Representation of 13 = 00000000 00000000 00000000 00001101
Kao rezultat, bitna operacija lijevog pomaka za 13 (i bilo koji drugi broj) može se razlikovati ovisno o broju bitova kojima su predstavljeni.
Budući da u 32-bitnom predstavljanju postoji mnogo više bitova koji se mogu pomicati ulijevo u usporedbi s 4-bitnim prikazom.
