C++ Référence Manuel

Opérateurs de calcul binaire ++Dans ce tutoriel, nous allons apprendre les opérateurs de calcul binaire en utilisant des exemples en C

Les opérateurs de calcul binaire. ++Dans C

Dans, les opérateurs de calcul binaire appliquent des opérations sur les données d'entiers de niveau de bits individuels. Ces opérations incluent les tests, les réglages ou les déplacements des bits réels. Par exemple,
a & b;

a | b; ++C'est C6Contient

， c'est-à-dire 0000

Ces opérateurs sont nécessaires car l'unité arithmétique et logique (ALU) du CPU de l'ordinateur effectue des opérations arithmétiques au niveau des bits.Attention :

1. C ++Les opérateurs de calcul binaire ne peuvent être utilisés qu'avec les types de données char et int.

Opérateur ET binaire1Quand et seulement quand les deux opérandes sont1. Sinon, il renverra 0.

Le tableau suivant montre comment fonctionne l'opérateur AND binaire. Supposons que a et b soient deux nombres qui ne peuvent prendre que des valeurs binaires, c'est-à-dire1et les opérandes 0.

Attention : surLe tableau est appelé "tableau de vérité" par l'opérateur AND binaire.

Regardons deux entiers12和25Opérations de ET binaire :

12　= 00001100 (binaire)
25　= 00011001　binaire
//12和25Opérations de ET binaire
　　　　　00001100
& 00011001
　　　　　_________
　　　　　00001000 =　8　(décimal)

Exemple1：按位与（&）

#include <iostream>
using namespace std;
int main() {
　　　　//Déclaration de variables
　　　　int a =　12, b =　25;
　　　　cout << "a = " << a << endl;
　　　　cout << "b = " << b << endl;
　　　　cout << "a & b = " << (a & b) << endl;
　　　　return 0;
}

Résultat de la sortie

a =　12
b =　25
a & b =　8

Dans cet exemple, nous avons déclaré deux variables a et b. Ici, veuillez noter cette ligne,

cout << "a & b = " << (a & b) << endl;

Ici, nous exécutons l'opérateur de ET binaire (&) entre les variables a et b.

2. C ++opérateur de OR ( | )

si au moins un opérateur est1alors l'opérateur de OR ( | ) retourne1. Sinon, retourne 0.

Le tableau de vérité suivant montre comment fonctionne l'opérateur de OR bit à bit. Supposonsa和bqui peuvent ne prendre que des valeurs binaires (c'est-à-dire1ou 0) deopérateurs. Sinon,

Regardons deux entiers12和25opérations de OR bit à bit :

12　= 00001100 (binaire)
25　= 00011001　binaire
//12和25opérations de OR bit à bit
　　　　00001100
| 00011001
　　　　_________
　　　　00011101　　=　29　(décimal)

Exemple2：opérateur de OR ( | )

#include <iostream>
int main() {
　　　　int a =　12, b =　25;
　　　　cout << "a = " << a << endl;
　　　　cout << "b = " << b << endl;
　　　　cout << "a | b = " << (a | b) << endl;
　　　　return 0;
}

Résultat de la sortie

a =　12
b =　25
a | b =　29

dansopérateur de ORoù a = 12et b = 25donne29。

3. C ++opérateur de XOR ( ^ )

lorsque l'un des opérateurs est1alors l'opérateur de XOR ^ retourne1. Mais si les deux opérateurs sont tous deux 0, ou si les deux sont1alors le résultat est 0.

Le tableau de vérité suivant montre comment fonctionne l'opérateur de OR bit à bit. Supposonsa和bqui peuvent ne prendre que des valeurs binaires (c'est-à-dire1ou 0) deopérateurs. Sinon,

Regardons deux entiers12和25opérations de XOR bit à bit :

12　= 00001100 (binaire)
25　= 00011001　binaire
//12和25opérations de XOR bit à bit
　　　　00001100
^ 00011001
　　　　_________
　　　　00010101　　=　21　(décimal)

Exemple3：opérateur de XOR ( ^ )

#include <iostream>
int main() {
　　　　int a =　12, b =　25;
　　　　cout << "a = " << a << endl;
　　　　cout << "b = " << b << endl;
　　　　cout << "a ^ b = " << (a ^ b) << endl;
　　　　return 0;
}

Résultat de la sortie

a =　12
b =　25
a ^ b =　21

a = 12et b = 25le résultat de l'opérateur de XOR bit à bit est21。

4. C ++opérateur de complément bit à bit

l'opérateur de complément bit à bit est un opérateur unaire (qui agit sur un seul opérateur). Il est représenté par ~, qui change le nombre binaire1changeons1。

Il est important de noter que le complément bit à bit de tout entier N est égal à -(N+1）。Par exemple

Par exemple, un entier35. Selon les règles,35le complément bit à bit devrait être-(35 +1) = -36. Maintenant, regardons si nous obtenons la bonne réponse.

35　= 00100011　binaire
//　en utilisant l'opérateur de complément bit à bit
~ 00100011　
　__________
　　11011100

Dans l'exemple ci-dessus, nous obtenons00100011(35）complement à =11011100. Si nous convertissons le résultat en décimal, nous obtenons220。

Cependant, il est important de noter que nous ne pouvons pas convertir directement le résultat en décimal pour obtenir la sortie nécessaire. Cela est dû au résultat binaire11011100équivaut également à-36。

Pour comprendre cela, nous devons d'abord calculer-36sortie binaire. Nous utilisons2pour calculer le nombre binaire des entiers négatifs. Le

2complement à

Dans l'arithmétique binaire,1complement à1,1et que nous changeons1ajoutons1Si nous changeons2complement à.

Par exemple,

36　= 00100100 (binaire)
1complement à =　11011011　
2的补码 :　　　
11011011
　+　　　　　　　　　　　1
_________
11011100

在这里，我们可以看到36的2的补码(即-36)是11011100。 该值相当于35的按位补码。

因此，我们可以说35的位补码是-36。

Exemple4：按位补码

#include <iostream>
int main() {
　　　　int num1　=　35;
　　　　int num2　=　-150;
　　　　cout << "~(" << num1　<< ") = " << (~num1) << endl;
　　　　cout << "~(" << num2　<< ") = " << (~num2) << endl;
　　　　return 0;
}

Résultat de la sortie

~(35) =　-36
~(-150) =　149

在上面的示例中，我们声明了两个整数变量num1和num2，并分别用值35和-150初始化它们。
然后我们分别用代码(~num1)和(~num2)计算它们的位补码，并将它们显示在屏幕上。

35的按位补码 =　-　(35　+　1) =　-36
即 ~35　=　-36
-150的按位补码 =　-　(-150　+　1) =　-　(-149) =　149
即 ~(-150) =　149

这正是我们在输出中得到的。

C ++移位运算符

C ++编程中有两个移位运算符：

• 右移运算符 >>

• 左移运算符 <<

1、C ++右移运算符（>>）

右移运算符将所有位向右移一定数量的指定位。用>>表示。

当我们向右移动任何数字时，最低有效位将被丢弃，而最高有效位将被零替换。

从上图可以看到，我们有一个4位数字。当我们对其执行1位。

结果，最右边的位被丢弃(Discarded)，而最左边的位保持为空。此空位由0代替（Replacement Bit）。

2、C ++左移运算符

左移位运算符将所有位向左移位一定数量的指定位。用<<表示。

从上图可以看到，我们有一个4位数字。当我们对其执行1位左移操作时，每个单独的位向左移1位。

结果，最左边的位被丢弃(Discarded)，而最右边的位保持为空。此空位由0代替（Replacement Bit）。

Exemple5：移位运算符

#include <iostream>
int main() {
　　　　//Déclarer deux variables entières
　　　　int num =　212, i;
　　　　//Opération de décalage vers la droite
　　　　cout << "Décalage vers la droite :" << endl;
　　　　//Utiliser une boucle for pour décaler num de la position 0 vers la droite3位
　　　　for (i = 0; i <　4; i++) {
　　　　　　　　cout << "212　>> " << i << " = " << (212　>> i) << endl;
　　　　}
　　　　//Opération de décalage vers la gauche
　　　　cout << "\nDécalage vers la gauche :" << endl;
　　　　//Utiliser une boucle for pour décaler num de la position 0 vers la gauche3位
　　　　for (i = 0; i <　4; i++) {
　　　　　　　　cout << "212　<< " << i << " = " << (212　<< i) << endl;
　　　　}
　　　　return 0;
}

Résultat de la sortie

Déplacement à droite :
212　>>　0　=　212
212　>>　1　=　106
212　>>　2　=　53
212　>>　3　=　26
Déplacement à gauche :
212　<<　0　=　212
212　<<　1　=　424
212　<<　2　=　848
212　<<　3　=　1696

À partir de la sortie du programme ci-dessus, nous pouvons déduire que pour tout nombreN，le résultat de l'opérateur de déplacement à droite est :

N　>>　0　=　N
N　>>　1　=　(N　>>　0)　/　2
N　>>　2　=　(N　>>　1)　/　2
N　>>　3　=　(N　>>　2)　/　2

etc.

De même, le résultat de l'opérateur de déplacement à gauche est :

N　<<　0　=　N
N　<<　1　=　(N　<<　0)　*　2
N　<<　2　=　(N　<<　1)　*　2
N　<<　3　=　(N　<<　2)　*　2

etc.

Ainsi, nous pouvons conclure que,

N　>>　m　=　[　N　>>　(m-1)　]　/　2
N　<<　m　=　[　N　<<　(m-1)　]　*　2