Ebben az oktatóanyagban példák segítségével megismerkedhetünk a bitenkénti operátorokkal a C ++ nyelven.
A C ++ nyelven a bitenkénti operátorok az egész adatokkal műveleteket végeznek az egyes bitszinteken. Ezek a műveletek magukban foglalják a tényleges bitek tesztelését, beállítását vagy eltolását. Például,
a & b; a | b;
Itt van egy lista a C ++ -ba tartozó 6 bitenkénti operátorról.
| Operátor | Leírás |
|---|---|
& | Bitenkénti ÉS kezelő |
| | Bitenként vagy Vezérlő |
^ | Bitenkénti XOR kezelő |
~ | Bitenkénti kiegészítő kezelő |
<< | Bitenkénti váltás bal kezelő |
>> | Bitenkénti váltás jobb kezelővel |
Ezekre az operátorokra azért van szükség, mert a számítógép CPU-jában található aritmetikai-logikai egység (ALU) bit szinten végez aritmetikai műveleteket.
Megjegyzés: bitműveletek csak akkor használható együtt charés intadattípusok.
1. C ++ bitenkénti ÉS kezelő
A bitenkénti AND & operátor akkor és akkor ad vissza 1 értéket, ha mindkét operandus 1 . Ellenkező esetben 0-t ad vissza .
Az alábbi táblázat bemutatja a bitenkénti ÉS operátor működését. Legyen a és b két olyan operandus, amelyek csak bináris értékeket vehetnek fel, azaz 1 és 0 .
| a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Megjegyzés: A fenti táblázat a bitenkénti ÉS operátor "Igazság táblája" néven ismert .
Vessünk egy pillantást két egész szám bitenkénti ÉS műveletére:
12 = 00001100 (bináris formátumban) 25 = 00011001 (bináris formátumban) // 12-es és 25-es bitenkénti ÉS művelete 00001100 és 00011001 _________ 00001000 = 8 (tizedesjegyben)
1. példa: Bitenkénti ÉS
#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; )
Kimenet
a = 12 b = 25 a & b = 8
A fenti példában két a és b változót deklaráltunk. Itt vegye észre a sort,
cout << "a & b = " << (a & b) << endl;
Itt bitenkénti AND műveletet hajtunk végre az a és b változók között.
2. C ++ bitenként VAGY kezelő
A bitenkénti OR | operátor 1-et ad vissza, ha az operandusok közül legalább az egyik 1 . Ellenkező esetben 0-t ad vissza .
Az alábbi igazságtáblázat bemutatja a bitenkénti OR operátor működését. Legyen a és b két olyan operandus, amelyek csak bináris értékeket vehetnek fel, azaz 1 vagy 0 .
| a | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Nézzük a bitenkénti OR művelet két egész szám 12 és 25 :
12 = 00001100 (bináris formátumban) 25 = 00011001 (bináris formátumban) bitenkénti VAGY a 12 és a 25 művelete 00001100 | 00011001 _________ 00011101 = 29 (tizedesjegyben)
2. példa: Bitenként vagy VAGY
#include int main() ( int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a | b = " << (a | b) << endl; return 0; )
Kimenet
a = 12 b = 25 a | b = 29
A bitenkénti VAGY A a = 12és b = 25ad 29.
3. C ++ Bitenként XOR operátor
A bitenkénti XOR ^ operátor akkor és akkor ad vissza 1 értéket, ha az egyik operandus értéke 1 . Ha azonban mindkét operandus 0 , vagy ha mindkettő 1 , akkor az eredmény 0 .
Az alábbi igazságtáblázat bemutatja a bitenkénti XOR operátor működését. Legyen a és b két olyan operandus, amelyek csak bináris értékeket vehetnek fel, azaz 1 vagy 0 .
| a | b | a b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Nézzük meg két egész szám 12 és 25 bitenkénti XOR műveletét:
12 = 00001100 (bináris formátumban) 25 = 00011001 (bináris formátumban) A 12 és 25 bitenkénti XOR művelete 00001100 00011001 _________ 00010101 = 21 (tizedesjegyben)
3. példa: Bitenként 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; )
Kimenet
a = 12 b = 25 a b = 21
A és ad bitenkénti XOR értéke .a = 12b = 2521
4. C ++ bitenkénti kiegészítő kezelő
A bitenkénti komplementer operátor unáris operátor (csak egy operanduson működik). Azt jelöli ~, amely megváltoztatja bináris számjegy 1- , hogy 0 és 0 , hogy 1- .
Bitenkénti kiegészítés
Fontos megjegyezni, hogy bármely N egész szám bitenkénti komplementere egyenlő - (N + 1) . Például,
Tekintsünk egy egész 35-et . A szabály szerint a 35 bitenkénti komplementere legyen - (35 + 1) = -36 . Most nézzük meg, hogy megkapjuk-e a helyes választ vagy sem.
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 >>.
Ha tetszőleges számot tolunk jobbra, a legkevésbé jelentős biteket elvetjük, míg a legjelentősebbeket nulla váltja fel.
egy kicsit Right Shift
Amint a fenti képen láthatjuk, van egy 4 bites számunk . Amikor egy bites jobboldali eltolási műveletet hajtunk végre rajta, minden egyes bitet 1 bittel jobbra tolunk.
Ennek eredményeként a jobb szélső bit eldobásra kerül, míg a bal oldali bit üres marad. Ezt a megüresedést 0 váltja fel .
6. C ++ bal váltás kezelője
A bal váltás operátora az összes bitet bizonyos számú megadott bit által balra tolja . Jelöli <<.
egy kicsit Bal váltás
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
Ennek eredményeként a 13-as (és bármely más szám) bitenkénti balra tolási művelete eltérhet az általuk képviselt bitek számától függően.
Mivel a 32 bites ábrázolásban sokkal több bitet lehet balra tolni, összehasonlítva a 4 bites ábrázolással.
