În acest tutorial, vom afla despre operatorii bit-bit în C ++ cu ajutorul exemplelor.
În C ++, operatorii biți efectuează operațiuni pe date întregi la nivel de biți individual. Aceste operații includ testarea, setarea sau schimbarea biților reali. De exemplu,
a & b; a | b;
Iată o listă cu 6 operatori pe biți incluși în C ++.
| Operator | Descriere |
|---|---|
& | Operator bit și bit |
| | Operator OR bit sau bit |
^ | Operator Bitwise XOR |
~ | Operator de completare bitwise |
<< | Comutator stânga spre stânga |
>> | Operator Shift în dreapta bit |
Acești operatori sunt necesari deoarece Unitatea Aritmetică-Logică (ALU) prezentă în CPU-ul computerului efectuează operațiuni aritmetice la nivel de biți.
Notă: Operatorii bitwise pot fi folosiți doar alături charși inttipurile de date.
1. C ++ Bitwise AND Operator
De la nivel de bit și & operatorul returnează 1 dacă și numai dacă ambele operanzii sunt 1 . În caz contrar, returnează 0 .
Tabelul următor demonstrează funcționarea operatorului ȘI bit . Fie a și b doi operanzi care pot lua doar valori binare adică 1 și 0 .
| A | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Notă: Tabelul de mai sus este cunoscut sub numele de "Tabelul Adevărului" pentru operatorul bitwise AND .
Să aruncăm o privire la operațiunea bit și ȘI a două numere întregi 12 și 25:
12 = 00001100 (În binar) 25 = 00011001 (În binar) // În funcție de bit ȘI Funcționarea 12 și 25 00001100 și 00011001 _________ 00001000 = 8 (În zecimal)
Exemplul 1: ȘI bit
#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; )
Ieșire
a = 12 b = 25 a & b = 8
În exemplul de mai sus, am declarat două variabile a și b. Aici, observați linia,
cout << "a & b = " << (a & b) << endl;
Aici, performăm în sensul bitului ȘI între variabilele a și b.
2. C ++ Operator bit bit SAU
La nivel de bit SAU | operatorul returnează 1 dacă cel puțin unul dintre operanzi este 1 . În caz contrar, returnează 0 .
Următorul tabel de adevăr demonstrează funcționarea operatorului SAU în biți . Fie a și b doi operanzi care pot lua doar valori binare adică 1 sau 0 .
| A | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Să ne uităm la operațiunea OR în biți a două numere întregi 12 și 25 :
12 = 00001100 (În binar) 25 = 00011001 (În binar) În funcție de biți SAU Operațiune de 12 și 25 00001100 | 00011001 _________ 00011101 = 29 (În zecimal)
Exemplul 2: SAU bit
#include int main() ( int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a | b = " << (a | b) << endl; return 0; )
Ieșire
a = 12 b = 25 a | b = 29
Nivel de bit SAU a a = 12și b = 25dă 29.
3. Operator X ++ Bitwise XOR
XOR logic ^ Operatorul returnează 1 dacă și numai dacă unul dintre operanzi este 1 . Cu toate acestea, dacă ambii operanzi sunt 0 sau dacă ambii sunt 1 , atunci rezultatul este 0 .
Următorul tabel de adevăr demonstrează funcționarea operatorului XOR în biți . Fie a și b doi operanzi care pot lua doar valori binare adică 1 sau 0 .
| A | b | a b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Să ne uităm la operația XOR în biți a două numere întregi 12 și 25:
12 = 00001100 (în binar) 25 = 00011001 (în binar) Operațiune XOR pe biți de 12 și 25 00001100 00011001 _________ 00010101 = 21 (în zecimal)
Exemplul 3: Bitwise 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; )
Ieșire
a = 12 b = 25 a b = 21
XOR la nivel de bit a a = 12și b = 25dă 21.
4. Operator de completare C ++ pe biți
Operatorul de biți complement este un operator unar (funcționează pe un singur operand). Se notează prin ~faptul că modifică cifrele binare 1 la 0 și 0 la 1 .
Complement bitwise
Este important să rețineți că complementul în biți al oricărui număr întreg N este egal cu - (N + 1) . De exemplu,
Să considerăm un număr întreg 35 . Conform regulii, complementul bititic al lui 35 ar trebui să fie - (35 + 1) = -36 . Acum, să vedem dacă obținem răspunsul corect sau nu.
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 >>.
Când deplasăm orice număr spre dreapta, biții cei mai puțin semnificativi sunt aruncați, în timp ce cei mai semnificativi biți sunt înlocuiți cu zerouri.
un pic Shift dreapta
După cum putem vedea din imaginea de mai sus, avem un număr de 4 biți . Atunci când efectuăm o operație de schimbare dreaptă de un bit pe acesta, fiecare bit individual este deplasat la dreapta cu 1 bit.
Ca rezultat, bitul cel mai drept este eliminat, în timp ce bitul cel mai stâng rămâne liber. Acest post vacant este înlocuit cu un 0 .
6. Operator de schimbare stânga C ++
Operatorul de schimbare din stânga mută toate biți spre stânga cu un anumit număr de biți specificat . Se notează cu <<.
un bit Shift Stânga
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
Ca rezultat, operațiunea de deplasare pe stânga pentru 13 (și orice alt număr) poate fi diferită în funcție de numărul de biți prin care sunt reprezentați.
Deoarece în reprezentarea pe 32 de biți , există mult mai mulți biți care pot fi deplasați la stânga în comparație cu reprezentarea pe 4 biți .
