Annexe 1 : les opérateurs de bits




Des opérations de coneion semblables à celles qu'éffectuent les opérateur logiques sur des expressions, sont également réalisables surles bits de deux données. Ici l'opération correspondante est appliquée en parallèle (donc en même temps) sur chaque bit individuel des données. Outre les opérations logiques ET, OU et NON sur les bits on peut également éffectuer des opérations de décalage. Toutes les opérations de bits exigent des opérandes entiers.

Opérateur Opération Exemple
Opérateurs logiques de bits
Binaire &

|

^ 		Connexion Binaire ET

Connexion binaire OU
(OU inclusif)
Connexion binaire OU
(OU exclusif) 		x & y

x | y

x^y
Unaire ~ Non binaire ( complement à 1 de x ) ~x
Opérateurs de décalage
Binaire >>

<< 		Décalage de y bits vers la droite

Décalage de y bits vers la gauche 		x>>y

x<


Opérateur logiques de bits


Les opérateur logiques de bits exécutent les opérations logiques ET, OU, OU exclusif et NON sur tous les bits, pris un à un, de leurs opérandes entiers. Ce faisant, les règles de connexion suivantes sont appliquées :

bit1 bit2 ~bit1 bit1 & bit2 bit1 | bit2 bit1 ^ bit2
0

0

1

1
0

1

0

1
1

1

0

0
0

0

0

1
0

1

1

1
0

1

1

0


ET binaire



On voit à la lecture du tableau que la conneion ET de deux bits ne donne un bit activé ou 1 que si les deux bits de dpéart ont la valeur 1, donc sont positionnés. Dans tout les autres cas, la connexion ET donne la valeur 0 pour le bit resultat.


char x=10, y = 50;


on range dans x et y les series de bits :


00001010 /* valeur décimale 10 */
00110010 /* valeur décimale 10 */


Le ET binaire de x et y :


x & y


donne au niveau bit :


   00001010
& 00110010
--------------
   00000010


le resultat (00000010) correspond à la valeur décimale 2.
Nous aurions pu faire ainsi :


printf("%d", x & y);


OU binaire



Le OU binaire existe sous deux variantes. Le OU non exclusif (inclusif) donne un bit résultat égal à 0 seulement si les deux bits de départ valaient 0. Dans tout les autres cas le résultat sera un bit positionné c'est à dire égal à 1. C'est le connecteur OU analogue à celui que l'on utilise dans les opérateur logiques.
Voyons uun exemple révélateur.


Il pleut le matin


et


il pleut l'apres-midi


L'une peut être vrai sans que la seconde le soit. De même le seconde peut être vraie sans que la première soit vraie. Mais les deux peuvent être vrai (il peut tres bien pleuvoir toute la journée). Il en va autrement avec le OU exclusif. Prennons un exemple révélateur otujours dans le même principe :


Il pleut


et


Il ne pleut pas


Ces deux expressions se contredisent si elles doivent être vrai en même temps (il pleut ou il ne pleut pas, il n'y as pas d'état intermédiaire). Ainsi dans l'assertion liée :


Il pleut OU il ne pleut pas


C'est soit la première assertion (il pleut) qui est vrai et l'autre fausse, ou la seconde assertion qui est vraie (il ne pleut pas) et la première qui est fausse. Mais pas les deux à la fois.
Ainsi le OU exclusif donne un bit de résultat si un et un seul des deux bits de départ possède la valeur 1. Au contraire si les deux bits de départ ont la même valeur (que se soit 0 ou 1) le bit résultant prendra la valeur 0.


int x = 10, y = 50;


le OU binaire inclusif :


x | y


donne le résultat :


   00001010
|  00110010
--------------
   00111010


le resultat (00111010) correspond à la valeur décimale 58.
NLe OU binaire exclusif :


x ^ y


donne :


   00001010
^ 00110010
--------------
   00111000


le resultat (00111000) correspond à la valeur décimale 56.


NON binaire



Le NON binaire, symbolisé par l'opérateur unaire ~, provoque le complement à 1 d'un nombre entier. Ainsi chaque bits de ce nombre valant 1 aura la valeur 0 et chaque bit ayant la valeur 0 prendra la valeur 1.
Notre variable x contenant la valeur 10 contient la série binaire :


00001010


La négation logique :


~x


donne la serie binaire :


11110101


soit la valeur décimale 245


Il ne pleut pas


Positionnement et désactivation de bits


Les opérateurs & et | permettent de désactiver(donner la valeur 0) ou de positionner(donner la valeur 1) de manière ciblée les divers bits d'une donnée.
Voyons l'avantage de cette technique. On a souvent besoin d'informations qui repondent à une question par OUI ou NON. On s'interesse ainsi à l'état d'un élement et non à sa quantitié. Prennons pour exemple la gestion d'un fichier ; un fichier peut être en lecture uniquement ou non, soit caché soit visible... Ainsi nous pourrions remplacer la question :

Quels sont les attributs du fichier ?


par les questions :

Le fichier est-il en lecture uniquement ?

Le fichier est-il caché ?

Le fichier est-il archivé ?


Chacune de ses trois question peut être répondue par OUI ou par NON.
Il est ainsi possible pour chacune de ses questions d'utiliser un seul bit pour contenir la réponse. Ainsi quand le bit sera positionné (1) cela équivaudra à un OUI pour notre question et quand ce bit sera désactivé (0) cela équivaudra à un NON.
On peut utiliser une variable char qui possède 8 bits (1 octets) ce qui est largement suffisant pour notre exemple (nous n'avons besoin que de 3 bits ici).


unsigned char attributsFichier;


Dans cette variable nous utiliserons les 3eme quatrième et cinquième bits pour respectivement répondre à nos trois questions.



attributs du fichier



L'image montre que le fichier est ici en lecture seule et qu'il est archivé, par contre le fait que le quatrième bit soit désactivé montre que le fichier n'est pas caché.
Si nous voulons changer les attributs du fichier il faudra changer les bits correspondant en les mettants à 0 s'il sont à 1 ou le contraire. Voyons comment réaliser cette opération


Positionnement de bits


Le connecteur OU (inclusif) appliqué à deux bits produit un bit de valeur 1 si au moins un des bits de départ est égal à 1. Pour que le quatrième bit qui est actuellement à 0 soit positionné nous devrons donc le connecter avec un bit de valeur 1. Car nous avons vu que n'importe que bit connecté avec un autre bit positionné (égal à 1) par l'opérateur de bit OU prendra la valeur 1, nous seront donc sur que notre bit sera ainsi positionné. Mais les autres bit ne doivent pas changer, or la aussi nous savons que n'importe quel bit connecté avec un bit égal à 0 par l'opérateur OU ne changera pas de valeur.
Voyons cela plus en détails.
Notre variable attributsFichier correspond à la valeur binaire


00010100


nous devons la connecter avec le champs de bit par l'opérateur OU :


00001000


qui correspond à la valeur 8 :


   00010100 notre variable
|  00001000 notre valeur (8)
--------------
   00011100 résultat : activation du 4ème bit
ce qui correspond à l'instruction :


attributsFichier = attributsFichier | 8;


  Voici une astuce fort utile pour trouver la valeur à connecter avec une variable pour en positionner un de ses bits.
Si vous voulez positionner le bit situé en position n (le premier bit à la position 0) il vous suffit de connecter votre variable avec le nombre 2(n-1). Ainsi pour positionner le 4ème bit de attributsFichier nous avons fait "flag | 8" car 8 est égale à 23 ( 3 =4 - 1).


désactivation de bits


Pour desactiver un bit nous utiliserons l'opérateur &. Un ET binaire appliqué à 2 bits ne donne 1 que si ces deux bits sont positionnés (1). Si nous voulons desactiver le 5ème bit nous devons le connecter avec un bit de valeur 0 par l'intermédiaire de l'opérateur ET binaire. Les autres bits devrons être connectés avec un bit de valeur 1 pour conserver leur valeur d'origine. Le masque binaire à connecter avec la variable attributsFichier sera donc :


11101111 /*décimal 239*/


l'opération à réaliser est donc :


   00011100 notre variable
|  11101111 notre valeur (8)
--------------
   00001100 résultat : désactivation du 5ème bit
ce qui correspond à l'instruction :


attributsFichier = attributsFichier & 239;


  Pour désactiver le nième bit d'un nombre il suffit de faire : 2(n-1) et d'en prendre la négation c'est à dire d'utiliser l'opérateur NON soit donc : ~2(n-1). Exemple : pour desactiver le 5ème bit nous aurions pu faire : "attributsFichier & (~8)"


annexes


les séquences d'échappement
Le système hexadécimal
Le système octal
Argument
paramêtre
Chaîne de caractères


[  Précédent  |  Index  |  Suivant  ]


par Valentin BILLOTTE
Last update: 07/27/2000