V tomto tutoriále sa pomocou príkladov dozvieme o bitových operátoroch v C ++.
V C ++ bitové operátory vykonávajú operácie s celočíselnými údajmi na individuálnej bitovej úrovni. Medzi tieto operácie patrí testovanie, nastavovanie alebo posúvanie skutočných bitov. Napríklad,
a & b; a | b;
Tu je zoznam 6 bitových operátorov zahrnutých v C ++.
| Prevádzkovateľ | Popis |
|---|---|
& | Bitový operátor AND |
| | Bitový operátor OR |
^ | Bitový operátor XOR |
~ | Operátor bitového doplnku |
<< | Operátor bitového posunu vľavo |
>> | Operátor bitového posunu doprava |
Tieto operátory sú potrebné, pretože aritmeticko-logická jednotka (ALU) prítomná v CPU počítača vykonáva aritmetické operácie na bitovej úrovni.
Poznámka: Bitové operátory je možné používať iba vedľa typov údajov chara inttypov údajov.
1. C ++ bitový operátor AND
Tieto bitové AND & operátor vracia 1 práve vtedy, keď obaja operandy sú 1 . V opačnom prípade vráti hodnotu 0 .
Nasledujúca tabuľka demonštruje prácu bitového operátora AND . Nech a a b sú dva operandy, ktoré môžu nadobúdať iba binárne hodnoty, tj. 1 a 0 .
| a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Poznámka: Vyššie uvedená tabuľka je pre bitový operátor AND známa ako „Pravdivá tabuľka“ .
Pozrime sa na bitovú operáciu AND dvoch celých čísel 12 a 25:
12 = 00001100 (v binárnom formáte) 25 = 00011001 (v binárnom formáte) // bitové operácie AND a prevádzka 12 a 25 00001100 a 00011001 _________ 00001000 = 8 (v desatinnom formáte)
Príklad 1: Bitový operátor 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; )
Výkon
a = 12 b = 25 a & b = 8
Vo vyššie uvedenom príklade sme deklarovali dve premenné a a b. Tu si všimnite riadok,
cout << "a & b = " << (a & b) << endl;
Tu vykonávame bitové AND medzi premennými a a b.
2. C ++ bitový operátor OR
Tieto bitové OR | operátor vracia 1 , ak aspoň jeden z operandov je 1 . V opačnom prípade vráti hodnotu 0 .
Nasledujúca tabuľka pravdy demonštruje prácu bitového operátora OR . Nech a a b sú dva operandy, ktoré môžu nadobúdať iba binárne hodnoty, tj. 1 alebo 0 .
| a | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Pozrime sa na bitovú operáciu ALEBO dvoch celých čísel 12 a 25 :
12 = 00001100 (binárne) 25 = 00011001 (binárne) bitové ALEBO prevádzka 12 a 25 00001100 | 00011001 _________ 00011101 = 29 (v desiatkovej sústave)
Príklad 2: Bitové ALEBO
#include int main() ( int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a | b = " << (a | b) << endl; return 0; )
Výkon
a = 12 b = 25 a | b = 29
Bitový OR of a = 12a b = 25dáva 29.
3. C ++ bitový operátor XOR
Bitový XOR ^ operátor vracia 1 práve vtedy, keď jeden z operandov je 1 . Ak sú však oba operandy 0 alebo ak sú oba 1 , potom je výsledok 0 .
Nasledujúca tabuľka pravdy demonštruje prácu bitového operátora XOR . Nech a a b sú dva operandy, ktoré môžu nadobúdať iba binárne hodnoty, tj. 1 alebo 0 .
| a | b | a b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Pozrime sa na bitovú operáciu XOR dvoch celých čísel 12 a 25:
12 = 00001100 (v binárnom formáte) 25 = 00011001 (v binárnom formáte) Bitová operácia XOR v rozsahu 12 a 25 00001100 00011001 _________ 00010101 = 21 (v desatinnom formáte)
Príklad 3: Bitový 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; )
Výkon
a = 12 b = 25 a b = 21
Bitový XOR of a = 12a b = 25dáva 21.
4. Operátor bitových doplnkov C ++
Operátor bitového doplnku je unárny operátor (funguje iba na jednom operande). Označuje sa tým, ~že sa menia binárne číslice 1 až 0 a 0 až 1 .
Bitový doplnok
Je dôležité si uvedomiť, že bitový doplnok ľubovoľného celého čísla N sa rovná - (N + 1) . Napríklad,
Zvážte celé číslo 35 . Podľa pravidla by bitový doplnok 35 mal byť - (35 + 1) = -36 . Teraz sa pozrime, či dostaneme správnu odpoveď alebo 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 >>.
Keď posunieme ľubovoľné číslo doprava, najmenej významné bity sa zahodia, zatiaľ čo najvýznamnejšie bity sa nahradia nulami.
jeden bit Right Shift
Ako vidíme z obrázku vyššie, máme 4-bitové číslo . Keď na ňom vykonáme jednobitovú operáciu pravého posunu, každý jednotlivý bit sa posunie doprava o 1 bit.
Výsledkom je, že bit úplne vpravo je zahodený, zatiaľ čo bit najviac vpravo zostáva prázdny. Toto voľné miesto je nahradené nulou .
6. Operátor ľavého posuvu C ++
Operátor ľavý shift posunie všetky bity doľava od určitého počtu uvedených bitov . Označuje to <<.
jeden bit Ľavý posun
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
Výsledkom je, že bitová operácia ľavého posuvu pre 13 (a akékoľvek iné číslo) sa môže líšiť v závislosti od počtu bitov, ktorými sú reprezentované.
Pretože v 32-bitovej reprezentácii je oveľa viac bitov, ktoré je možné posunúť doľava v porovnaní so 4-bitovou reprezentáciou.
