Discussion :

[I-DEXX]

Bonjour,

Il y a peu je suis tombé sur le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
short s = readShort(); // fonction qui retourne un short int
int i = s >> 2;
int i2 = s & 3;

Je ne reconnais pas la technique utilisée ici. A quoi servent ces crochets et ces esperluettes ? J'ai pensé dans un premier temps qu'il s'agissait de flux, mais ça n'a rien donné .

merci d'avance .

[Bousk]

Bonjour,

ce sont des opérateurs sur les bits.

>> : décallage à droite
& : et binaire

[I-DEXX]

Merci beaucoup !

Ça va me permettre de chercher un tutoriel .

Bonne journée a vous.

[koala01]

Salut,

Une petite introduction au système binaire pour commencer.

Un ordinateur est un appareil électri(oni)que, qui va se contenter de manipuler du courent en le laissant passer ou non, d'une manière finalement fort proche de ce qui se fait avec des interrupteurs tout ce qu'il y a de plus classiques (tu sais, ceux qui ne permettent pas de faire varier l'intensité de la lumière :d).

Ces "interrupteurs", appelés bit, peuvent donc représenter deux valeurs : 1 si le courent passe, 0 si le courent ne passe pas.

Comme le fait de ne disposer que de deux valeurs est rarement suffisant, on a regroupé plusieurs bits ensembles afin de pouvoir représenter un nombre plus important de valeurs.

C'est ce qu'on appelle le byte et que l'on associe (par abus de langage) à l'octet en français, parce qu'il arrive souvent (mais ce n'est pas forcément le cas) qu'un byte soit composé de 8 bits. Considérons ici que c'est bel et bien le cas

Nous pouvons donc numéroter les bits de b0 à b7 en les numérotant (par convention) de gauche à droite, sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
b7      b0
 |      |
 00000000

où, s'il vaut 1, b0 représente la valeur 1 (2 exposant 0) et où, s'il vaut 1, b7 permet de représenter la valeur 128 (2 exposant 7).

Par facilité, on dira que b0 est le "bit de poids faible" et que b7 est le "bit de poids fort", de manière à garder les mêmes termes quel que soit le nombre de bits envisagé. Et c'est très bien parce que l'on peut, "classiquement" considérer que le type short est composé de 16 bits (mais encore une fois, ce n'est pas forcément le cas ).

au lieu d'avoir les bits numérotés de b0 à b7, nous pourrions (pour les besoins de la démonstration essentiellement) considérer qu'un short est composé de 16 bits, qui seraient numérotés (de droite à gauche toujours) de b0 à b15 sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
b15            b0
 |              |
 0000000000000000

où, s'il vaut 1, b0 correspond toujours à une valeur 1 (2 exposant 0) (et est toujours appelé "bit de poids faible") et où, si'l vaut 1, b15 correspond à une valeur 32768 (2 exposant 15)(et est toujours appelé "bit de poids fort").

tu l'auras donc compris : chaque fois que l'on se décale d'un bit vers la gauche, cela correspond à une multiplication par 2 et, à l'inverse, chaque fois que l'on se décale d'un bit vers la droite, cela correspond à une division par 2

Ainsi, le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int i = s >> 2;

représente comme Bousk l'a signalé, le décalage de l'ensemble des bits de s vers la droite.

Et comme on effectue un décalage de deux bits vers la droite, cela correspond, au final, à une division par 4 (2*2 ).

Quant à l'esperluette dans le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int i2 = s & 3;

elle correspond, comme Bousk l'a tout aussi bien dit, à l'opérateur ET binaire.

Il permet, pour faire simple, de récupérer tous les bits qui seraient à 1 aussi bien dans la valeur observée (s dans le code) que dans la valeur de comparaison (3) dans le code.

Et comme la valeur 3 est représentée par le code binaire 00000011 (sur 8 bits) et par le code binaire 0000000000000011 (sur 16 bits), on aura la certitude que la valeur de i2 correspondra

• à 0 (si les bits b0 et b1 de s sont tous les deux à 0),
• à 1 (si b0 est à 1 et que b1 est à 0 dans s),
• à 2 (si b0 est à 0 et b1 à 1 dans s) ou
• à 3 (si b0 et b1 sont tous les deux à 1 dans s).

Autrement dit, la valeur de i1 correspondra au modulo de (au reste de la division de) s par 4

Au final, ce code n'est qu'une écriture différente (qui n'apporte absolument rien de plus que la différence )(*) du code
short s = readShort(); // fonction qui retourne un short int

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int i = s / 4 ;
int i2 = s % 3 ;

(*)Fut un temps, bien loin maintenant, où le code que tu montres aurait, peut être, été plus rapide que la correspondance que j'en donne, avec de vieux compilateurs C parce que plus proche des instructions réellement exécutées par le processeur (le décalage de bit étant plus efficace qu'une division "normale" et l'utilisation de ce que l'on appelle un masque étant plus efficace que le calcul de la division afin d'en récupérer le reste).

A l'heure actuelle, cette différence n'existe plus pour les compilateur récents qui sont parfaitement en mesure de déterminer quand utiliser le décalage de bit ou un masque et quand utiliser la division et le modulo.

Par contre, cette écriture garde tout son attrait dans le sens où elle est peut être (parfois) plus proche de la manière dont un algorithme particulier peut avoir été décrit

[I-DEXX]

Merci beaucoup pour ce super tutoriel !

Je n'aurais pas pu rêver de plus clair et précis ! Cela va me permettre d'avancer dans mon travail

Bonne semaine a vous.

[Jean-Marc.Bourguet]

Ainsi, le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int i = s >> 2;

représente comme Bousk l'a signalé, le décalage de l'ensemble des bits de s vers la droite.
Au final, ce code n'est qu'une écriture différente (qui n'apporte absolument rien de plus que la différence )(*) du code
short s = readShort(); // fonction qui retourne un short int

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int i = s / 4 ;

C'est surtout une transformation incorrecte, le résultat pouvant étant vraisemblablement différent pour toutes les valeurs négatives. (Formellement le résultat est défini par l'implémentation, en pratique deux cas sont possibles, un qui introduit une copie du signe dans les bits de poids fort, un qui introduit des 0; le premier va donner (-1 >> 1) == -1, le second (-1 >> 1) == INT_MAX, alors que -1/4 == 0).

Fut un temps, bien loin maintenant, où le code que tu montres aurait, peut être, été plus rapide que la correspondance que j'en donne, avec de vieux compilateurs C parce que plus proche des instructions réellement exécutées par le processeur (le décalage de bit étant plus efficace qu'une division "normale" et l'utilisation de ce que l'on appelle un masque étant plus efficace que le calcul de la division afin d'en récupérer le reste).

Un compilo va rarement pouvoir prouver que la transformation est valable. Il peut soit faire une transformation similaire mais avec un ajustement pour les valeurs négatives, ou ne pas la faire; peu de chance qu'il trouve du code tout aussi efficace, à supposer que le programmeur n'a pas fait de bug en faisant cette transformation -- ce qui est du domaine du possible.