Comment passer valeurs binaires dans la programmation de c

Le langage de programmation C dispose de deux opérateurs binaires qui effectuent l'opération équivalente de “ Tout le monde se déplacer d'un cran vers la gauche (ou à droite) ”. La lt; lt; >> opérateurs et décalent les bits de valeur, leur marche vers la gauche ou la droite, respectivement. Voici le format pour le lt; lt; opérateur:

v = int lt; lt; comptage

int est une valeur entière. nombre est le nombre de places pour décaler les bits de la valeur vers la gauche. Le résultat de cette opération est mémorisée dans la variable v. Tous les bits qui sont décalés vers la gauche au-delà de la largeur de la int variable X sont perdus. Nouveaux bits déplacés de la droite sont toujours 0.

Comme avec la plupart non-sens binaire, il aide à voir visuellement ce qui se passe dans une valeur lorsque ses bits sont décalés.

Tout le monde de la piscine!

#include char * binbin (int n) -int main () {int BSHIFT, X-printf ("Entrez une valeur entre 0 et 255:") -scanf ("% d", BSHIFT) -pour (x = 0- XLT; 8 x ++) {printf ("% s n", binbin (BSHIFT)) - BSHIFT = BSHIFT lt; lt; 1-} return (0) -} char * binbin (int n) {bin static char [9] -int x-pour (x = 0 XLT; 8 x ++) {bin [x] = n 0x80? '1': '0'-n lt; lt; = 1-} bin [x] = ' 0'-retour (bin) -}

L'opération de déplacement a lieu à la ligne 15 dans tout le monde hors de la piscine !. La valeur de la variable BSHIFT est décalée vers la gauche d'un bit.

Exercice 1: Tapez le code source de tout le monde hors de la piscine! dans votre éditeur et de construire un nouveau projet.

L'effet net d'un décalage de bits gauche est de doubler une valeur. Cela est vrai jusqu'à un certain point: Évidemment, le plus à gauche vous passez, vous perdez quelques bits et la valeur cesse de doubler. En outre, cette astuce ne fonctionne que pour les valeurs non signées.

Exercice 2: Modifier le code source de tout le monde hors de la piscine! de sorte que la fonction printf () à la ligne 14 affiche également la valeur décimale de la BSHIFT variable. Vous devez également modifier la fonction binbin () de sorte qu'il affiche 16 chiffres au lieu de 8.

Voici le résultat lors de l'utilisation de la valeur 12:

Tapez une valeur entre 0 et 255: 120000000000001100 120000000000011000 240000000000110000 480000000001100000 960000000011000000 1920000000110000000 3840000001100000000 7680000011000000000 1536

Essayez la valeur 800 000 000 (ne tapez pas les virgules) pour voir comment la règle de doublement échoue que les valeurs gardent déplaçant vers la gauche. Voir également l'encadré proximité “ nombres binaires négatives ”.

Le >> opérateur de décalage fonctionne de façon similaire à la lt; lt; décaler l'opérateur, si les valeurs sont marchèrent vers la droite au lieu de la gauche. Tous les bits qui ont défilé hors de l'extrémité droite est éliminée, et seuls les bits à zéro sont insérés sur le côté gauche. Voici le format:

v = int >> comptage

int est une valeur entière, et compter est le nombre de places pour décaler les bits vers la droite. Le résultat est stocké dans la variable v.

Exercice 3: Modifiez le code source à partir de l'exercice 2 de sorte que l'opérateur de décalage à droite est utilisé au lieu du décalage à gauche à la ligne 15. Créer le programme.

Voici le résultat en utilisant la valeur 128:

Tapez une valeur entre 0 et 255: 1280000000010000000 1280000000001000000 640000000000100000 320000000000010000 160000000000001000 80000000000000100 40000000000000010 20000000000000001 1

Contrairement à la lt; lt; l'opérateur, l'>> est garantie pour couper toujours la valeur de moitié lorsque vous passez d'un chiffre vers la droite. En fait, l'opérateur >> est beaucoup plus rapide à utiliser sur une valeur entière que la / (division) l'opérateur de diviser une valeur de 2.

La lt; lt; >> opérateurs et ne sont disponibles que dans la langue de C. En C ++, les opérateurs similaires sont utilisés pour recevoir l'entrée standard et envoyer sortie standard.

Les nombres binaires sont toujours positifs, estimant que les valeurs d'un bit peut être seulement 1 ou 0 et non -1 et 0. Alors, comment l'ordinateur faire entiers signés? Facile: Il triche.

Le bit le plus à gauche dans une valeur binaire signé est connu sous le nom bit de signe. Lorsque ce bit est mis (égal à 1), la valeur est négative pour un int signé. Sinon, la valeur est lue comme positive.

Dans cet exemple, le bit de signe est défini pour un signed char. Les valeurs exprimées sont négatifs, ce qui est dans la gamme d'une variable signed char.

Dans cet exemple, le bit de signe est ignorée parce que la valeur est un unsigned char. Les valeurs ne peuvent être positifs, ce qui explique pourquoi la plage positive pour une variable non signée est plus grande que pour une variable signé.