W tym samouczku dowiemy się o operatorach bitowych w C ++ na przykładach.
W C ++ operatory bitowe wykonują operacje na danych całkowitych na poszczególnych poziomach bitów. Operacje te obejmują testowanie, ustawianie lub przesuwanie rzeczywistych bitów. Na przykład,
a & b; a | b;
Oto lista 6 operatorów bitowych zawartych w C ++.
| Operator | Opis |
|---|---|
& | Operator bitowy AND |
| | Operator bitowy OR |
^ | Operator bitowego XOR |
~ | Operator dopełnienia bitowego |
<< | Operator przesunięcia bitowego w lewo |
>> | Operator przesunięcia bitowego w prawo |
Operatory te są niezbędne, ponieważ jednostka arytmetyczno-logiczna (ALU) obecna w CPU komputera wykonuje operacje arytmetyczne na poziomie bitów.
Uwaga: operatory bitowe mogą być używane tylko razem z typami danych chari int.
1. Operator bitowy AND w języku C ++
Operator bitowy AND & zwraca 1 wtedy i tylko wtedy, gdy oba operandy mają wartość 1 . W przeciwnym razie zwraca 0 .
W poniższej tabeli przedstawiono działanie operatora bitowego AND . Niech a i b będą dwoma operandami, które mogą przyjmować tylko wartości binarne, tj. 1 i 0 .
| za | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Uwaga: powyższa tabela jest nazywana „tablicą prawdy” dla operatora bitowego AND .
Przyjrzyjmy się operacji bitowej AND na dwóch liczbach całkowitych 12 i 25:
12 = 00001100 (binarnie) 25 = 00011001 (binarnie) // Bitowe operacja AND na liczbach 12 i 25 00001100 i 00011001 _________ 00001000 = 8 (dziesiętnie)
Przykład 1: bitowe AND
#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; )
Wynik
a = 12 b = 25 a & b = 8
W powyższym przykładzie zadeklarowaliśmy dwie zmienne a i b. Tutaj, zwróć uwagę na linię,
cout << "a & b = " << (a & b) << endl;
Tutaj wykonujemy bitowe AND między zmiennymi a i b.
2. Operator bitowy OR w C ++
Operator bitowy OR | zwraca 1, jeśli przynajmniej jeden z operandów ma wartość 1 . W przeciwnym razie zwraca 0 .
Poniższa tabela prawdy ilustruje działanie operatora bitowego OR . Niech a i b będą dwoma operandami, które mogą przyjmować tylko wartości binarne, tj. 1 lub 0 .
| za | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Spójrzmy na operację bitową OR na dwóch liczbach całkowitych 12 i 25 :
12 = 00001100 (binarnie) 25 = 00011001 (binarnie) Bitowo LUB Operacja 12 i 25 00001100 | 00011001 _________ 00011101 = 29 (dziesiętnie)
Przykład 2: Bitowe OR
#include int main() ( int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a | b = " << (a | b) << endl; return 0; )
Wynik
a = 12 b = 25 a | b = 29
Bitowym OR z a = 12i b = 25daje 29.
3. Bitowy operator XOR w języku C ++
Operator bitowy XOR ^ zwraca 1 wtedy i tylko wtedy, gdy jeden z operandów ma wartość 1 . Jeśli jednak oba operandy mają wartość 0 lub oba mają wartość 1 , wynikiem jest 0 .
Poniższa tabela prawdy demonstruje działanie bitowego operatora XOR . Niech a i b będą dwoma operandami, które mogą przyjmować tylko wartości binarne, tj. 1 lub 0 .
| za | b | a b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Spójrzmy na bitową operację XOR dwóch liczb całkowitych 12 i 25:
12 = 00001100 (binarnie) 25 = 00011001 (binarnie) Bitowo XOR Operacja 12 i 25 00001100 00011001 _________ 00010101 = 21 (dziesiętnie)
Przykład 3: Bitowe 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; )
Wynik
a = 12 b = 25 a b = 21
XOR bitowe od a = 12i b = 25daje 21.
4. Operator dopełniacza bitowego C ++
Operator dopełniacza bitowego jest operatorem jednoargumentowym (działa tylko na jednym operandzie). Oznacza to, ~że zmienia cyfry binarne 1 na 0 i 0 na 1 .
Uzupełnienie bitowe
Należy zauważyć, że bitowe uzupełnienie dowolnej liczby całkowitej N jest równe - (N + 1) . Na przykład,
Rozważmy liczbę całkowitą 35 . Zgodnie z regułą bitowe uzupełnienie liczby 35 powinno wynosić - (35 + 1) = -36 . Teraz zobaczmy, czy otrzymamy poprawną odpowiedź, czy nie.
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 >>.
Kiedy przesuwamy dowolną liczbę w prawo, najmniej znaczące bity są odrzucane, a najbardziej znaczące bity zastępowane są zerami.
jeden bit w prawo Shift
Jak widać na powyższym obrazku, mamy 4-bitową liczbę . Kiedy wykonujemy na nim jednobitową operację przesunięcia w prawo, każdy pojedynczy bit jest przesuwany w prawo o 1 bit.
W rezultacie najbardziej prawy bit jest odrzucany, podczas gdy najbardziej lewy bit pozostaje pusty. Ten wakat jest zastępowany przez 0 .
6. Operator C ++ w lewo
Operatora przesunięcia w lewo przenosi wszystkie bity w lewą stronę od pewnej liczby określonych bitów . Jest oznaczony <<.
jednobitowy lewy 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
W rezultacie bitowa operacja przesunięcia w lewo dla 13 (i dowolnej innej liczby) może się różnić w zależności od liczby bitów, które są reprezentowane.
Ponieważ w 32-bitowej reprezentacji jest znacznie więcej bitów, które można przesunąć w lewo w porównaniu z 4-bitową reprezentacją.
