Discussion :

[kloss]

Bonjour,
J'ai encore une question théorique

J'ai cru bien comprendre le fonctionnement des opérateurs >> et >>>. Par exemple il me paraît clair que 12 >> 2 correspond à 0...01101 >> 2, soit 0...00011, soit 3.

Mais il y a quelque chose qui m'échappe tout de même. Pourquoi, quand je décale d'un très grand nombre de bits, ne trouvé-je pas toujours 0 ?

Par exemple si je fais 500 >>> 100 je m'attends à avoir 0, hors cela renvoie 31. 500, comme tout entier, n'est codé que sur 32 bits, donc si je décale de 100 bits, je devrais avoir zéro, non ?

++ Kloss

[anykeyh]

>> correspond au shift to right (shr en asm) binaire. Donc 011011 >> 2 reverra 000110

>>> correspond au rotation on right (ror en asm) binaire. Donc 011011 >>> 2 renverra 110110

En fait le second deplace les bits a droite vers la gauche, tandis que le premier les gicle et fou des zero a gauche

[kloss]

En fait le second deplace les bits a droite vers la gauche, tandis que le premier les gicle et fou des zero a gauche

Oups là je ne suis pas tout à fait d'accord.
Selon moi, voilà le fonctionnement des opérateurs >> et >>>

>> décale les chiffres vers la droite, comble à gauche avec des 0 pour les nombres positifs, et avec des 1 pour les nombres négatifs.
>>> décale les chiffres vers la droite, comble à gauche avec des 0 pour tous les nombres, qu'ils soient positifs ou négatifs.

Prenons l'entier 2006, écrit sur 32 bits (le premier donne le signe du nombre, 0 pour les nombres positifs, 1 pour les nombres négatifs).
2006 = 0*2^30 + ... + 0 * 2^11 + 1 * 2^10 + 1 * 2^9 + 1 * 2^8 + 1 * 2^7 + 1 * 2^6 + 0 * 2^5 + 1 * 2^4 + 0 * 2^3 + 1 * 2^2 + 1 * 2^1 + 0 * 2^0, donc en binaire : 0000000000000000000011111010110

2006 >> 3 signifie qu'on décale tous les bits de 3 crans la droite ; les trois derniers bits disparaissent ; on comble les trois premiers avec des zéros. On obtient : 0000000000000000000000011111010
Cela fait : 0 * 2^30 + ... + 0 * 2^8 + 1 * 2^7 + 1 * 2^6 + 1 *2^5 + 1 * 2^4 + 1 * 2^3 + 0 * 2^2 + 1 * 2^1 + 0 * 2^0, donc en base 10 : 250.

L'opérateur >>> est identique à l'opérateur >> pour les nombres positifs, c'est-à-dire que 2006 >>> 3 = 250.

Prenons maintenant le nombre -2006. Comment on l'écrit en binaire ? C'est un peu plus compliqué : il faut partir de 2006 écrit en binaire, prendre l'opposé binaire (i.e. on remplace les 0 par des 1 et vice-versa), puis rajouter 1. Let's go !
On prend l'opposé binaire de 2006 : 1111111111111111111100000101001
On rajoute 1 : 1111111111111111111100000101010

Selon la règle énoncée en italique, -2006 >> 3 donne : 1111111111111111111111100000101
Pour savoir combien fait ce nombre en valeur absolue, on retire 1 et on prend l'opposé binaire, soit : 00000000000000000000000011111011. Ce nombre est égal à 251, donc notre nombre vaut -251.

-2006 >>> 3, au contraire, donne : 00011111111111111111111100000101.
C'est un nombre positif égal à : 1 * 2^28 + ... + 1 * 2^8 + 0 * 2^7 + 0 * 2^6 + 0* 2^4 + 0 * 2^3 + 1 * 2^2 + 0 * 2^1 + 1 * 2^0, soit 536870661.

Vous pouvez vérifier tout ça par vous-mêmes ! Le décalage vers la gauche existe aussi, c'est <<.

Maintenant, mon problème, c'est de comprendre pourquoi la valeur d'un entier décalé sur plus de 32 bits n'est pas nulle ; c'était l'exemple 500 >> 100.

Voili voilà merci pour votre aide

[kloss]

Ah j'ai compris.
En fait quand on fait x >> y, java exécute x >> (y%32). Autrement dit, 500 >> 100 = 500 >> 68 = 500 >> 36 = 500 >> 4 = 31.

++