I denna handledning lär vi oss om bitvisa operatorer i C ++ med hjälp av exempel.
I C ++ utför bitvisa operatörer operationer på heltaldata på den enskilda bitnivån. Dessa operationer inkluderar testning, inställning eller skiftning av de faktiska bitarna. Till exempel,
a & b; a | b;
Här är en lista med 6 bitvisa operatörer som ingår i C ++.
| Operatör | Beskrivning |
|---|---|
& | Bitvis OCH operatör |
| | Bitvis ELLER operatör |
^ | Bitvis XOR-operatör |
~ | Bitvis komplementoperatör |
<< | Bitvis förskjutning vänster operatör |
>> | Bitvis förskjutning höger operatör |
Dessa operatörer är nödvändiga eftersom den aritmetiska-logiska enheten (ALU) som finns i datorns CPU utför aritmetiska operationer på bitnivå.
Obs: Bitvis operatörer kan endast användas tillsammans med charoch intdatatyper.
1. C ++ bitvis och operatör
De bitvisa OCH & operatörs returnerar 1 om och endast om båda operanderna är ett . Annars returnerar den 0 .
Följande tabell visar hur bitvis AND- operatören fungerar . Låt a och b vara två operander som bara kan ta binära värden, dvs. 1 och 0 .
| a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Obs! Tabellen ovan är känd som "Sanningstabellen" för bitvis OCH- operatör.
Låt oss ta en titt på bitvis OCH- operation av två heltal 12 och 25:
12 = 00001100 (I binär) 25 = 00011001 (I binär) // Bitvis OCH manövrering av 12 och 25 00001100 & 00011001 _________ 00001000 = 8 (i decimal)
Exempel 1: Bitvis OCH
#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; )
Produktion
a = 12 b = 25 a & b = 8
I exemplet ovan har vi deklarerat två variabler a och b. Här, se raden,
cout << "a & b = " << (a & b) << endl;
Här utför vi bitvis OCH mellan variablerna a och b.
2. C ++ bitvis ELLER operatör
Den bitvisa ELLER- | operatören returnerar 1 om minst en av operanderna är 1 . Annars returnerar den 0 .
Följande sanningstabell visar hur bitvis OR- operatören fungerar . Låt a och b vara två operander som bara kan ta binära värden, dvs. 1 eller 0 .
| a | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Låt oss titta på bitvis ELLER- operation av två heltal 12 och 25 :
12 = 00001100 (i binär) 25 = 00011001 (i binär) bitvis ELLER användning av 12 och 25 00001100 | 00011001 _________ 00011101 = 29 (i decimal)
Exempel 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; )
Produktion
a = 12 b = 25 a | b = 29
Den bitvis OR av a = 12och b = 25ger 29.
3. C ++ Bitvis XOR-operatör
Den bitvisa XOR- ^ operatören returnerar 1 om och endast om en av operanderna är 1 . Men om båda operanderna är 0 , eller om båda är 1 , är resultatet 0 .
Följande sanningstabell visar hur den bitvisa XOR- operatören fungerar . Låt a och b vara två operander som bara kan ta binära värden, dvs. 1 eller 0 .
| a | b | a b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Låt oss titta på bitvis XOR- operation av två heltal 12 och 25:
12 = 00001100 (I binär) 25 = 00011001 (I binär) Bitvis XOR Användning av 12 och 25 00001100 00011001 _________ 00010101 = 21 (I decimal)
Exempel 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; )
Produktion
a = 12 b = 25 a b = 21
Den bitvisa XOR av a = 12och b = 25ger 21.
4. C ++ Bitvis komplementoperatör
Bitvis komplementoperatören är en unary operatör (fungerar bara på en operand). Det betecknas med ~att ändrar binära siffror 1 till 0 och 0 till 1 .
Bitvis komplement
Det är viktigt att notera att det bitvisa komplementet för alla heltal N är lika med - (N + 1) . Till exempel,
Betrakta ett heltal 35 . Enligt regeln bör det bitvisa komplementet på 35 vara - (35 + 1) = -36 . Låt oss nu se om vi får rätt svar eller inte.
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 flyttar valfritt tal åt höger kasseras de minst signifikanta bitarna , medan de viktigaste bitarna ersätts med nollor.
en bit Right Shift
Som vi kan se från bilden ovan har vi ett 4-bitarsnummer . När vi utför en enbits högerförskjutningsoperation på den, flyttas varje enskild bit åt höger med 1 bit.
Som ett resultat kastas den högsta biten bort medan den längst till vänster förblir ledig. Den här vakansen ersätts med ett 0 .
6. C ++ Left Shift-operatör
Den vänstra skiftoperatören skiftar alla bitar åt vänster med ett visst antal specificerade bitar . Det betecknas med <<.
en bit 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
Som ett resultat kan den bitvisa vänsterskiftningsoperationen för 13 (och vilket annat nummer som helst) vara olika beroende på antalet bitar de representeras av.
Eftersom det i 32-bitarsrepresentation finns många fler bitar som kan flyttas åt vänster jämfört med 4-bitarsrepresentation .
