I denne opplæringen vil vi lære om bitvise operatorer i C ++ ved hjelp av eksempler.
I C ++ utfører bitvise operatører operasjoner på heltallsdata på det enkelte bitnivå. Disse operasjonene inkluderer testing, innstilling eller forskyvning av de faktiske bitene. For eksempel,
a & b; a | b;
Her er en liste over 6 bitvise operatører inkludert i C ++.
| Operatør | Beskrivelse |
|---|---|
& | Bitvis OG operatør |
| | Bitvis ELLER operatør |
^ | Bitvis XOR-operatør |
~ | Bitvis komplementoperatør |
<< | Bitvis skift venstre operatør |
>> | Bitvis skift høyre operatør |
Disse operatørene er nødvendige fordi den aritmetiske-logiske enheten (ALU) i datamaskinens CPU utfører aritmetiske operasjoner på bitnivå.
Merk: Bitvis operatører kan bare brukes sammen med charog intdatatyper.
1. C ++ bitvis og operatør
De bitvis AND & operatør returnerer 1 hvis og bare hvis begge operandene er en . Ellers returnerer den 0 .
Tabellen nedenfor viser hvordan bitvis AND- operatør fungerer . La a og b være to operander som bare kan ta binære verdier, dvs. 1 og 0 .
| en | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Merk: Tabellen over er kjent som "Sannhetstabellen" for den bitvise AND- operatøren.
La oss ta en titt på bitvis OG- operasjon av to heltall 12 og 25:
12 = 00001100 (I binær) 25 = 00011001 (I binær) // Bitvis OG betjening av 12 og 25 00001100 & 00011001 _________ 00001000 = 8 (i desimal)
Eksempel 1: Bitvis OG
#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; )
Produksjon
a = 12 b = 25 a & b = 8
I eksemplet ovenfor har vi deklarert to variabler a og b. Her, legg merke til linjen,
cout << "a & b = " << (a & b) << endl;
Her utfører vi bitvis OG mellom variablene a og b.
2. C ++ bitvis ELLER operatør
Den bitvise ELLER- | operatoren returnerer 1 hvis minst en av operandene er 1 . Ellers returnerer den 0 .
Følgende sannhetstabell viser hvordan den bitvise OR- operatøren fungerer . La a og b være to operander som bare kan ta binære verdier, dvs. 1 eller 0 .
| en | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
La oss se på bitvis ELLER- operasjon av to heltall 12 og 25 :
12 = 00001100 (i binær) 25 = 00011001 (i binær) bitvis ELLER bruk av 12 og 25 00001100 | 00011001 _________ 00011101 = 29 (i desimal)
Eksempel 2: Bitvis ELLER
#include int main() ( int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a | b = " << (a | b) << endl; return 0; )
Produksjon
a = 12 b = 25 a | b = 29
Den bitvise ELLER av a = 12og b = 25gir 29.
3. C ++ bitvis XOR-operatør
Den bitvise XOR- ^ operatøren returnerer 1 hvis og bare hvis en av operandene er 1 . Men hvis begge operandene er 0 , eller hvis begge er 1 , er resultatet 0 .
Følgende sannhetstabell viser hvordan den bitvise XOR- operatøren fungerer . La a og b være to operander som bare kan ta binære verdier, dvs. 1 eller 0 .
| en | b | a b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
La oss se på den bitvise XOR- operasjonen av to heltall 12 og 25:
12 = 00001100 (i binær) 25 = 00011001 (i binær) bitvis XOR betjening av 12 og 25 00001100 00011001 _________ 00010101 = 21 (i desimal)
Eksempel 3: Bitvis 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; )
Produksjon
a = 12 b = 25 a b = 21
Den bitvise XOR av a = 12og b = 25gir 21.
4. C ++ bitvis komplementoperatør
Den bitvise komplementoperatøren er en unary operator (fungerer bare på en operand). Det er betegnet med ~at endrer binære sifre 1 til 0 og 0 til 1 .
Bitvis komplement
Det er viktig å merke seg at det bitvise komplementet til et helt tall N er lik - (N + 1) . For eksempel,
Tenk på et heltall 35 . I henhold til regelen skal det bitvise komplementet på 35 være - (35 + 1) = -36 . La oss nå se om vi får riktig svar eller ikke.
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 >>.
Når vi skifter et hvilket som helst tall til høyre, kastes de minst betydningsfulle bitene , mens de viktigste bitene blir erstattet av nuller.
en bit Right Shift
Som vi kan se fra bildet ovenfor, har vi et 4-bit nummer . Når vi utfører en en-bits høyre skiftoperasjon på den, blir hver enkelt bit forskjøvet til høyre med 1 bit.
Som et resultat blir den høyeste biten kastet, mens den venstre biten forblir ledig. Denne stillingen erstattes av en 0 .
6. C ++ Venstre skiftoperatør
Den venstre skifte operatør forskyver alle bit mot venstre ved et visst antall spesifiserte bit . Det er betegnet med <<.
en bit Venstre skift
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
Som et resultat kan den bitvise venstre-skiftoperasjonen for 13 (og hvilket som helst annet tall) være forskjellig avhengig av antall bits de er representert av.
For i 32-biters representasjon er det mange flere biter som kan skiftes til venstre sammenlignet med 4-bits representasjon.
