Dans ce didacticiel, nous allons en apprendre davantage sur les opérateurs binaires en C ++ à l'aide d'exemples.
En C ++, les opérateurs au niveau du bit effectuent des opérations sur des données entières au niveau du bit individuel. Ces opérations incluent le test, la définition ou le décalage des bits réels. Par exemple,
a & b; a | b;
Voici une liste de 6 opérateurs au niveau du bit inclus dans C ++.
| Opérateur | La description |
|---|---|
& | Opérateur AND au niveau du bit |
| | Opérateur OR au niveau du bit |
^ | Opérateur XOR au niveau du bit |
~ | Opérateur de complément au niveau du bit |
<< | Opérateur de décalage de bit à gauche |
>> | Opérateur de décalage binaire vers la droite |
Ces opérateurs sont nécessaires car l'unité arithmétique-logique (ALU) présente dans la CPU de l'ordinateur effectue des opérations arithmétiques au niveau du bit.
Remarque: les opérateurs au niveau du bit ne peuvent être utilisés qu'à côté des types de données charet int.
1. Opérateur ET binaire C ++
L' opérateur AND au niveau du bit & renvoie 1 si et seulement si les deux opérandes sont 1 . Sinon, il renvoie 0 .
Le tableau suivant illustre le fonctionnement de l' opérateur AND au niveau du bit . Soit a et b deux opérandes qui ne peuvent prendre que des valeurs binaires, c'est-à-dire 1 et 0 .
| une | b | un B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Remarque: La table ci-dessus est connue sous le nom de «Table de vérité» pour l' opérateur AND au niveau du bit .
Jetons un coup d'œil à l' opération ET au niveau du bit de deux entiers 12 et 25:
12 = 00001100 (en binaire) 25 = 00011001 (en binaire) // au niveau du bit ET Fonctionnement de 12 et 25 00001100 & 00011001 _________ 00001000 = 8 (en décimal)
Exemple 1: ET au niveau du bit
#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; )
Production
a = 12 b = 25 a & b = 8
Dans l'exemple ci-dessus, nous avons déclaré deux variables a et b. Ici, remarquez la ligne,
cout << "a & b = " << (a & b) << endl;
Ici, nous effectuons un ET au niveau du bit entre les variables a et b.
2. Opérateur OR binaire C ++
L' opérateur OR au niveau du bit | renvoie 1 si au moins l'un des opérandes est 1 . Sinon, il renvoie 0 .
La table de vérité suivante montre le fonctionnement de l' opérateur OR au niveau du bit . Soit a et b deux opérandes qui ne peuvent prendre que des valeurs binaires, c'est-à-dire 1 ou 0 .
| une | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Regardons l' opération OR au niveau du bit de deux entiers 12 et 25 :
12 = 00001100 (en binaire) 25 = 00011001 (en binaire) au niveau du bit OU Fonctionnement de 12 et 25 00001100 | 00011001 _________ 00011101 = 29 (en décimal)
Exemple 2: OU au niveau du bit
#include int main() ( int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a | b = " << (a | b) << endl; return 0; )
Production
a = 12 b = 25 a | b = 29
Le OU au niveau du bit de a = 12et b = 25donne 29.
3. Opérateur XOR binaire C ++
L' opérateur XOR au niveau du bit ^ renvoie 1 si et seulement si l'un des opérandes est 1 . Cependant, si les deux opérandes sont 0 , ou si les deux sont 1 , le résultat est 0 .
La table de vérité suivante montre le fonctionnement de l' opérateur XOR au niveau du bit . Soit a et b deux opérandes qui ne peuvent prendre que des valeurs binaires, c'est-à-dire 1 ou 0 .
| une | b | a b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Examinons l' opération XOR au niveau du bit de deux entiers 12 et 25:
12 = 00001100 (en binaire) 25 = 00011001 (en binaire) XOR bit à bit Fonctionnement de 12 et 25 00001100 00011001 _________ 00010101 = 21 (en décimal)
Exemple 3: XOR au niveau du bit
#include int main() ( int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a b = " << (a b) << endl; return 0; )
Production
a = 12 b = 25 a b = 21
Le XOR au niveau du bit de a = 12et b = 25donne 21.
4. Opérateur de complément au niveau du bit C ++
L'opérateur de complément au niveau du bit est un opérateur unaire (ne fonctionne que sur un seul opérande). Il est indiqué par ~cela change les chiffres binaires 1 à 0 et 0 à 1 .
Complément au niveau du bit
Il est important de noter que le complément au niveau du bit de tout entier N est égal à - (N + 1) . Par exemple,
Considérons un entier 35 . Conformément à la règle, le complément au niveau du bit de 35 doit être - (35 + 1) = -36 . Voyons maintenant si nous obtenons la bonne réponse ou non.
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 >>.
Lorsque nous décalons un nombre vers la droite, les bits les moins significatifs sont ignorés, tandis que les bits les plus significatifs sont remplacés par des zéros.
un peu Shift vers la droite
Comme nous pouvons le voir sur l'image ci-dessus, nous avons un nombre de 4 bits . Quand on effectue un un bit opération de décalage vers la droite sur elle, chaque bit est décalé vers la droite de 1 bit.
En conséquence, le bit le plus à droite est ignoré, tandis que le bit le plus à gauche reste vide. Cette vacance est remplacée par un 0 .
6. Opérateur de décalage gauche C ++
L' opérateur de décalage gauche décale tous les bits vers la gauche d'un certain nombre de bits spécifiés . Il est indiqué par <<.
décalage gauche d'un bit
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
En conséquence, l' opération de décalage à gauche au niveau du bit pour 13 (et tout autre nombre) peut être différente en fonction du nombre de bits par lesquels ils sont représentés.
Parce que dans la représentation 32 bits , il y a beaucoup plus de bits qui peuvent être décalés vers la gauche par rapport à la représentation 4 bits .
