Si nous nous représentons le motif de bits constitutif d'un entier comme une séquence allant de la gauche (les bits de poids forts) vers la droite (les bits de poids faibles), une première intervention envisageable consiste à décaler cette séquence de quelques positions vers la gauche ou la droite.
Nous obtenons alors un motif semblable mais avec des bits supprimés dans la direction du décalage et un nombre équivalent de bits insérés du côté opposé.
Les expressions

expr<<N

et

expr>>N

provoquent respectivement le décalage de N bits vers la gauche (les poids forts) et vers la droite (les poids faibles) de l'expression expr✍.

Pour expérimenter cela, il faut compléter la fonction test_shift() de cette façon : Remarquez que pour l'instant nous ne nous intéressons qu'à des entiers non-signés (uint32_t ici) ; la cas des entiers signés sera étudié dans cette section.
Pour les afficher fidèlement, même quand ils deviendront très grands, le format "%u" est utilisé avec la fonction standard printf().
Il s'agit de visualiser le résultat de quelques décalages à gauche et à droite sur quelques valeurs.
Le type du résultat d'un tel décalage est celui de la valeur décalée ; la promotion vers le type int (éventuellement unsigned) s'applique toutefois pour les entiers de plus petit taille (voir cette section).

Relancez la fabrication du programme exécutable et exécutez-le afin d'observer les résultats.
Vous devriez constater qu'un décalage nul est sans effet et que les autres décalages sont assimilables à des multiplications ou des divisions entières par des puissances de deux.
En effet, décaler l'écriture d'un nombre exprimé dans une base de numération revient à multiplier ou diviser ce nombre par une puissance de la base choisie ; pensez à la représentation en base dix pour vous en convaincre.

Réalisez un nouveau module constitué uniquement du fichier d'en-tête word32.h pour l'instant ; il sera dédié à quelques opérations classiques sur des mots de 32 bits (uint32_t).
La plupart de ces opérations ne seront constituées que de très peu d'instructions, elles pourront par conséquent être qualifiées d'inline static (voir cette section) et donc être directement définies dans ce fichier d'en-tête.
Dans un premier temps, ce module doit simplement fournir la fonction Word32_one() suivante : Son rôle est de fournir un motif de 32 bits dont seul celui qui est désigné par le paramètre vaudra 1 et tous les autres vaudront 0.
Par convention, les programmeurs numérotent les bits en commençant à 0 au niveau de celui ayant le poids le plus faible.
Ainsi, si cette fonction est appelée avec le paramètre 0, le résultat sera 1, le paramètre 1 produira 2, 2 produira 4, 3 produira 8 et ainsi de suite✍ jusqu'à un paramètre valant au plus 31.
Il suffit donc, pour produire ce résultat, de partir d'un motif de bits valant 1 et de le décaler vers la gauche selon le paramètre transmis.
Toutefois, un compilateur rigoureux devrait indiquer qu'une conversion d'un entier signé vers un entier non-signé risque d'entraîner une perte d'information.
En effet, la constante littérale 1 est signée donc son décalage le sera aussi.
Pour spécifier au compilateur que nous partons d'une valeur littérale non-signée il suffit de lui ajouter le suffixe u : la constante littérale 1u est ainsi non-signée et son décalage le restera.

Complétez maintenant la fonction test_shift() pour afficher le résultat de cette nouvelle fonction pour tous les bits de 0 à 31.
L'affichage doit toujours utiliser le format "%u" afin que tous les résultats soient correctement représentés.
Après une nouvelle compilation et la relance du programme exécutable, vous devriez voir apparaître toutes les puissances de deux correspondantes.

De la même façon que les opérations arithmétiques usuelles combinent les motifs de bits de deux opérandes pour produire le motif de bits du résultat, selon les règles de l'addition par exemple, il existe des opérateurs bit-à-bit qui combinent ces motifs de bits selon les règles des opérations logiques élémentaires.
Ces opérateurs sont & pour l'opération et (and), | pour l'opération ou (or) et ^ pour l'opération ou-exclusif (x-or).

  c=a&b; // bitwise AND          c=a|b; // bitwise OR           c=a^b; // bitwise X-OR

  a7 a6 a5 a4 a3 a2 a1 a0        a7 a6 a5 a4 a3 a2 a1 a0        a7 a6 a5 a4 a3 a2 a1 a0
& b7 b6 b5 b4 b3 b2 b1 b0      | b7 b6 b5 b4 b3 b2 b1 b0      ^ b7 b6 b5 b4 b3 b2 b1 b0
  ───────────────────────        ───────────────────────        ───────────────────────
  c7 c6 c5 c4 c3 c2 c1 c0        c7 c6 c5 c4 c3 c2 c1 c0        c7 c6 c5 c4 c3 c2 c1 c0
   ( avec ci = ai & bi )          ( avec ci = ai | bi )          ( avec ci = ai ^ bi )

Comme explicité sur cette illustration (qui se limite à des entiers de huit bits pour réduire l'écriture), ces opérations consistent à appliquer individuellement l'opération logique sur chaque paire de bits qui sont en même position dans chacun des deux opérandes.
Cela est très différent des opérateurs logiques du langage C qui ne dépendent que de l'éventuelle nullité de ses opérandes :

Pour expérimenter ces opérations, il faut réaliser la fonction test_bitwise() dans le fichier prog09.c. Elle devra être invoquée depuis le programme principal et, après avoir fabriqué à nouveau le programme exécutable, son exécution vous fera constater la variété de valeurs produites par ces opérations.

Afin de mieux comprendre les valeurs affichées précédemment, nous devons ajouter la fonction Word32_test() au fichier d'en-tête word32.h.
Elle renvoie un booléen indiquant si la valeur passée en argument a le bit dont le numéro est spécifié par un autre argument entier valant 1 ou non.
Il suffit pour ceci de fabriquer un masque binaire avec ce seul bit positionné (grâce à la fonction Word32_one()) et de le combiner selon l'opérateur & avec la valeur transmise.
Partout où le masque a ses bits nuls, le résultat aura aussi des bits nuls (en logique, 0 et x vaut 0, quel que soit x) ; au contraire, le seul emplacement du masque pour lequel le bit n'est pas nul conduira à une recopie du bit correspondant de la valeur d'entrée dans le résultat (en logique, 1 et x vaut x).
Le résultat sera donc entièrement nul si le bit en question était nul dans la valeur d'entrée, et sera non-nul si le bit en question était non-nul ; l'interprétation booléenne de ce résultat renseigne donc sur l'état du bit choisi dans la valeur d'entrée.

Il est désormais possible de faire précéder, dans la fonction test_bitwise(), l'affichage des calculs par une boucle qui, grâce à la fonction Word32_test(), teste un à un tous les bits de la valeur courante et n'affiche la position que de ceux qui sont non-nuls. Ainsi, après une nouvelle compilation et une relance du programme exécutable, l'énumération des bits présents dans les valeurs combinées vous aidera à interpréter les résultats des opérations préalablement observées.

Pour terminer avec ces opérations bit-à-bit, veuillez noter qu'il est possible de les combiner à une opération d'affectation comme nous le faisons déjà pour les opérations arithmétiques usuelles (voir cette section).
Ainsi, les expressions

a&=b

,

c|=d

et

e^=f

sont respectivement équivalentes à

a=a&b

,

c=c|d

et

e=e^f

.

La fonction Word32_test(), qui permet de tester l'état d'un bit particulier, a déjà été réalisée.
Nous la réutilisons ici dans une nouvelle fonction Word32_dump() qui sera déclarée dans word32.h et définie dans word32.c✍. Son rôle est d'écrire dans pattern une chaîne de trente-deux caractères représentant l'état des bits de value.
Elle passe pour cela en revue les trente-deux bits de la valeur en question, à l'aide de la fonction Word32_test(), pour inscrire le caractère littéral '.' ou 'X' selon l'état du bit concerné (0 ou 1).
Pour une lecture facilitée, les bits de poids forts sont représentés en début de chaîne et les poids faibles en fin.

Pour tester cette fonction, il faut réaliser dans le fichier prog09.c la fonction test_dump_load() suivante : Son tableau de 33 caractères est initialisé à 0 ce qui assure la terminaison de la chaîne au delà des 32 premiers caractères.
Elle devra être invoquée depuis le programme principal et, après avoir fabriqué à nouveau le programme exécutable, son exécution vous fera constater ce que produit Word32_dump() pour quelques dizaines de valeurs.

Nous ajoutons maintenant dans le fichier word32.h la fonction Word32_set() suivante : Son rôle est de forcer à 1 un bit choisi dans un entier de type uint32_t du contexte appelant.
Il suffit pour ceci de fabriquer un masque binaire avec ce seul bit positionné (grâce à la fonction Word32_one()) et de le combiner selon l'opérateur | avec la valeur à modifier.
Partout où le masque a ses bits nuls, les bits de la valeur seront inchangés (en logique, 0 ou x vaut x) ; au contraire, le seul emplacement du masque pour lequel le bit n'est pas nul forcera à 1 le bit de la valeur à modifier (en logique, 1 ou x vaut 1, quel que soit x).

Cette nouvelle fonction peut désormais être exploitée dans la fonction Word32_load() qu'on ajoutera à word32.c. Son rôle est complémentaire à Word32_dump() : elle analyse la chaîne de trente-deux caractères qui lui est transmise afin de constituer un entier de type uint32_t qu'elle renverra.
Il suffit pour ceci de partir d'une valeur nulle et de forcer à 1, à l'aide de la fonction Word32_set(), les bits de cette valeur lorsqu'un caractère vaut 'X' (en considérant que la chaîne commence par les poids forts).

La boucle de la fonction test_load_save() sera complétée pour vérifier que l'analyse de la chaîne de caractères par la fonction Word32_load() fournit bien la valeur qui avait été transmise à la fonction Word32_dump() lorsqu'elle a produit cette chaîne. Fabriquez à nouveau ce programme et exécutez-le afin de vérifier que nous obtenons bien le résultat attendu.

Nous venons de vérifier que

De la même façon qu'en arithmétique et en logique il existe des opérateurs unaires pour transformer un unique opérande✍, les opérations bit-à-bit fournissent un opérateur de complémentation ~ dont le rôle est d'inverser l'état de chaque bit de l'entier considéré : les 0 deviennent des 1 et les 1 deviennent des 0.
Cela est très différent de la négation logique qui ne dépend que de l'éventuelle nullité de son opérande : la négation logique

b=!a;

est équivalente à

b=(a==0) ? true : false;

alors que le complément bit-à-bit

b=~a;

peut produire toute une variété de valeurs.

Pour constater l'effet de cet opérateur, il faut réaliser la fonction test_complement() dans le fichier prog09.c. Elle réutilise la fonction Word32_dump() pour visualiser les motifs de bits de la variable v1 et de son complémentaire v2.
Elle devra être invoquée depuis le programme principal et, après avoir fabriqué à nouveau le programme exécutable, son exécution vous fera constater la complémentarité des motifs de bits affichés.

Nous réutilisons cette nouvelle connaissance pour compléter le fichier word32.h avec la fonction Word32_clear() suivante : Son rôle est de forcer à 0 un bit choisi dans un entier de type uint32_t du contexte appelant.
Il suffit pour ceci de fabriquer un masque binaire avec ce seul bit positionné (grâce à la fonction Word32_one()), de lui appliquer la complémentation afin qu'il soit désormais constitué d'un unique bit nul et de le combiner selon l'opérateur & avec la valeur à modifier.
Partout où le masque a ses bits non-nuls, les bits de la valeur seront inchangés (en logique, 1 et x vaut x) ; au contraire, le seul emplacement du masque pour lequel le bit est nul forcera à 0 le bit de la valeur à modifier (en logique, 0 et x vaut 0, quel que soit x).

Pour tester le bon fonctionnement de cette nouvelle fonctionnalité, nous complétons la fonction test_complement() afin de fabriquer une variable v3 qui sera également le complément de v1 mais en forçant certains de ses bits à 0. Nous commençons par donner à v3 une valeur initiale constituée exclusivement de bits valant 1.
Un tel motif s'obtient simplement en utilisant le complément de la constante littérale 0u.
Ensuite, pour chaque bit de v1, lorsque la fonction Word32_test() indique la valeur true, il suffit d'utiliser la fonction Word32_clear() pour forcer à 0 le bit correspondant dans v3.
La fonction Word32_dump() sert encore à rendre explicite le résultat de ce traitement.
Fabriquez à nouveau ce programme et exécutez-le afin de vérifier que le motif ainsi produit pour v3 est bien identique à celui obtenu sur v2 par complémentation de v1.

Nous venons de vérifier que le forçage à 0 du bit N d'un entier value peut être obtenu par l'opération :

value&=~(1u<<N);

.

De manière générale, il est très rare que des opérations bit-à-bit soient nécessaires sur des entiers signés.
Si le signe a effectivement une importance, c'est que la valeur doit être interprétée d'un point de vue arithmétique et ne doit pas être considérée comme une simple séquence de bits à manipuler individuellement.
C'est pour cette raison que nous avons utilisé le type non-signé uint32_t dans nos investigations autour de ce thème.
Néanmoins, les opérations bit-à-bit sont quand même autorisées sur les entiers signés et fonctionnent de la même façon à une exception près : le décalage vers la droite (vers les poids faibles) nécessite une attention particulière.

Pour aborder ce point particulier il est nécessaire de comprendre la représentation qui est utilisée pour les entiers signés.
À cette fin, nous réalisons dans le fichier prog09.c la fonction test_signed() suivante : Elle utilise trois variables v1, v2 et v3 de type int32_t ; la première recoit une valeur positive quelconque, la deuxième son opposé et la troisième son complément.
Pour chacune de ces trois variables, nous visualisons le motif de bits avec la fonction Word32_dump() (un cast est nécessaire pour le paramètre non-signé).
Elle devra être invoquée depuis le programme principal et, après avoir fabriqué à nouveau le programme exécutable, son exécution vous permettra d'observer le motif produit et la valeur entière pour chacune des trois variables.
Vous devriez constater que v2, qui contient une valeur négative, a ses bits de poids forts positionnés, tout comme v3 qui contient le complément d'une valeur positive.
Les motifs de v2 et v3 sont même très similaires et la valeur de v3 est juste inférieure d'une unité à celle de v2.
Nous en déduisons que nous pouvons émuler l'opposé d'une valeur entière en ajoutant 1 à son complément : il s'agit de la représentation en complément-à-deux.
L'intérêt de cette solution tient dans le fait que les opérations arithmétiques usuelles sont réalisées exactement de la même façon, que les valeurs entières soient positives ou négatives.
(https://en.wikipedia.org/wiki/Two%27s_complement)

Pour vérifier ce constat, ajoutons au fichier word32.h la fonction Word32_negate() suivante : Son rôle est d'émuler la négation de son paramètre de type uint32_t en renvoyant son complément-à-deux.
La fonction test_signed() doit alors être complétée comme ceci : La variable v4 est ainsi fabriquée en calculant explicitement le complément-à-deux de v1 et son motif ainsi que sa valeur sont affichés.
Fabriquez à nouveau ce programme et exécutez-le afin de comparer les motifs produits pour v4 et v2 ; ils doivent être identiques.

Plus haut, nous constations que les opérations de décalage pouvaient s'interpréter du point de vue arithmétique comme des multiplications ou des divisions entières par des puissances de deux.
Multiplier ou diviser par une quantité positive ne doit pas changer le signe ; il faut donc que les opérations de décalage respectent cette contrainte sur les entiers signés.
Nous avons également constaté que la représentation en complément-à-deux des valeurs négatives positionnait les bits de poids forts.
Puisque le décalage vers la droite (les poids faibles) nécessite l'injection de bits au niveau des poids forts, il convient donc de les choisir avec précaution afin de respecter le signe du résultat.

Expérimentons en complétant à nouveau la fonction test_signed(). Les variables v5 et v6 sont obtenues en décalant de quelques bits vers la droite les valeurs de v1 et v2 qui sont respectivement positive et négative et nous affichons leurs motifs de bits.
Après compilation et relance du programme nous constatons, en ce qui concerne v5 un comportement similaire à ce que nous avons vu précédemment : des bits nuls ont été injectés au niveau des poids forts.
En revanche, il en est tout autrement pour la variable v6 : des bits non-nuls ont été injectés au niveau des poids forts, ce qui permet au résultat de rester négatif et conforme à l'arithmétique.
Complétons à nouveau la même fonction. Cette fois nous partons de la valeur de v2 (négative) convertie en entier non-signé✍ que nous décalons de quelques bits vers la droite pour initialiser la variable v7 (non-signée donc).
Après compilation et relance du programme nous constatons un comportement similaire au cas positif : des bits nuls ont été injectés au niveau des poids forts et l'affichage sous forme d'entier signé n'est alors plus conforme aux attentes.

Nous venons de vérifier que le décalage vers la droite implique la propagation du bit de poids fort (injection de bits identiques au bit de poids fort initial) dans le cas d'un entier signé alors que des 0 sont systématiquement utilisés dans le cas d'un entier non-signé.
Un comportement similaire a lieu lorsqu'un entier est transformé en un entier plus large : dans le cas d'un entier signé (int16_t vers int32_t par exemple), les bits de poids forts introduits sont identiques au bit de poids fort initial, alors que des 0 sont systématiquement utilisés dans le cas d'un entier non-signé (uint16_t vers uint32_t par exemple).