In deze tutorial zullen we met behulp van voorbeelden leren over bitsgewijze operatoren in C ++.
In C ++ voeren bitsgewijze operatoren bewerkingen uit op gegevens van gehele getallen op het individuele bitniveau. Deze bewerkingen omvatten het testen, instellen of verschuiven van de feitelijke bits. Bijvoorbeeld,
a & b; a | b;
Hier is een lijst met 6 bitsgewijze operatoren die zijn opgenomen in C ++.
| Operator | Omschrijving |
|---|---|
& | Bitwise EN Operator |
| | Bitsgewijs OF Operator |
^ | Bitwise XOR-operator |
~ | Bitwise-complementoperator |
<< | Bitwise Shift Left Operator |
>> | Bitwise Shift Right Operator |
Deze operators zijn nodig omdat de Arithmetic-Logic Unit (ALU) die aanwezig is in de CPU van de computer rekenkundige bewerkingen op bitniveau uitvoert.
Opmerking: Bitwise-operators kunnen alleen naast charen intgegevenstypen worden gebruikt .
1. C ++ Bitwise AND Operator
De bitsgewijze AND- & operator retourneert 1 als en alleen als beide operanden 1 zijn . Anders retourneert het 0 .
De volgende tabel toont de werking van de bitsgewijze AND- operator. Laat a en b twee operanden zijn die alleen binaire waarden kunnen aannemen, dwz 1 en 0 .
| een | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Opmerking: de bovenstaande tabel staat bekend als de "Truth Table" voor de bitsgewijze AND- operator.
Laten we eens kijken naar de bitsgewijze EN- bewerking van twee gehele getallen 12 en 25:
12 = 00001100 (in binair) 25 = 00011001 (in binair) // bitsgewijs EN werking van 12 en 25 00001100 & 00011001 _________ 00001000 = 8 (in decimaal)
Voorbeeld 1: Bitwise 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; )
Uitvoer
a = 12 b = 25 a & b = 8
In het bovenstaande voorbeeld hebben we twee variabelen a en b gedeclareerd. Let hier op de lijn,
cout << "a & b = " << (a & b) << endl;
Hier voeren we bitsgewijs EN uit tussen variabelen a en b.
2. C ++ Bitwise OF Operator
De bitsgewijze OR- | operator retourneert 1 als ten minste een van de operanden 1 is . Anders retourneert het 0 .
De volgende waarheidstabel toont de werking van de bitsgewijze OR- operator. Laat a en b twee operanden zijn die alleen binaire waarden kunnen aannemen, dwz 1 of 0 .
| een | b | een | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Laten we eens kijken naar de bitsgewijze OR- bewerking van twee gehele getallen 12 en 25 :
12 = 00001100 (In binair) 25 = 00011001 (In binair) Bitgewijs OF Werking van 12 en 25 00001100 | 00011001 _________ 00011101 = 29 (in decimaal)
Voorbeeld 2: Bitwise 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; )
Uitvoer
a = 12 b = 25 een | b = 29
De bitsgewijze OF van a = 12en b = 25geeft 29.
3. C ++ Bitwise XOR-operator
De bitsgewijze XOR- ^ operator retourneert 1 als en alleen als een van de operanden 1 is . Als beide operanden echter 0 zijn , of als beide 1 zijn , is het resultaat 0 .
De volgende waarheidstabel toont de werking van de bitsgewijze XOR- operator. Laat a en b twee operanden zijn die alleen binaire waarden kunnen aannemen, dwz 1 of 0 .
| een | b | a b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Laten we eens kijken naar de bitsgewijze XOR- bewerking van twee gehele getallen 12 en 25:
12 = 00001100 (In Binair) 25 = 00011001 (In Binair) Bitwise XOR Werking van 12 en 25 00001100 00011001 _________ 00010101 = 21 (In decimaal)
Voorbeeld 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; )
Uitvoer
a = 12 b = 25 a b = 21
De bitsgewijze XOR van a = 12en b = 25geeft 21.
4. C ++ Bitwise Complement Operator
De bitsgewijze complementoperator is een unaire operator (werkt op slechts één operand). Het wordt aangeduid door ~dat de binaire cijfers 1 in 0 en 0 in 1 verandert .
Bitsgewijze aanvulling
Het is belangrijk op te merken dat het bitsgewijze complement van een geheel getal N gelijk is aan - (N + 1) . Bijvoorbeeld,
Beschouw een geheel getal 35 . Zoals aangegeven in de regel, de bitsgewijze complement van 35 zou moeten zijn - (35 + 1) = -36 . Laten we nu kijken of we het juiste antwoord krijgen of niet.
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 >>.
Wanneer we een getal naar rechts schuiven, worden de minst significante bits weggegooid, terwijl de meest significante bits worden vervangen door nullen.
een beetje Right Shift
Zoals we op de bovenstaande afbeelding kunnen zien, hebben we een 4-bits nummer . Wanneer we er een één-bit naar rechts-verschuivingsbewerking op uitvoeren, wordt elke individuele bit met 1 bit naar rechts verschoven.
Als gevolg hiervan wordt het meest rechtse bit weggegooid, terwijl het meest linkse bit vrij blijft. Deze vacature wordt vervangen door een 0 .
6. C ++ Linker Shift-operator
De linker shift-operator verschuift alle bits naar links met een bepaald aantal gespecificeerde bits . Het wordt aangeduid met <<.
een beetje Left 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
Als resultaat kan de bitsgewijze verschuiving naar links voor 13 (en elk ander getal) verschillen, afhankelijk van het aantal bits dat ze vertegenwoordigen.
Omdat er bij 32-bits weergave veel meer bits zijn die naar links kunnen worden verschoven in vergelijking met 4-bits weergave.
