Ma question est simple : pourquoi 1 d=E9cal=E9 =E0 droite de n'importe
quel multiple de 32 donne 1, et 0 pour toutes les autres valeurs ?
J'utilise C#2. Normalement le d=E9calage fait tomber les bits qui
d=E9passent dans l'oubli, et comble les nouveaux avec des z=E9ros non ?
Je suis sur un Athlon XP, donc 32 bits. Si =E7a fait =E7a avec les
multiples du nombre de bits de la machine, =E7a n'aura aucun sens sur
une machine 64 bits...
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Antoine Polatouche
Vivien Parlat a écrit :
Bonjour,
Ma question est simple : pourquoi 1 décalé à droite de n'importe quel multiple de 32 donne 1, et 0 pour toutes les autres valeurs ? J'utilise C#2. Normalement le décalage fait tomber les bits qui dépassent dans l'oubli, et comble les nouveaux avec des zéros non ?
D'après la doc:
If the first operand is an int or uint (32-bit quantity), the shift count is given by the low-order five bits of the second operand (second operand & 0x1f).
If the first operand is a long or ulong (64-bit quantity), the shift count is given by the low-order six bits of the second operand (second operand & 0x3f).
0x1f = 31 et donc 32 et ses multiples valent 0 comme 2ème opérateur quand le premier opérateur est int32...
Vivien Parlat a écrit :
Bonjour,
Ma question est simple : pourquoi 1 décalé à droite de n'importe
quel multiple de 32 donne 1, et 0 pour toutes les autres valeurs ?
J'utilise C#2. Normalement le décalage fait tomber les bits qui
dépassent dans l'oubli, et comble les nouveaux avec des zéros non ?
D'après la doc:
If the first operand is an int or uint (32-bit quantity), the shift
count is given by the low-order five bits of the second operand (second
operand & 0x1f).
If the first operand is a long or ulong (64-bit quantity), the shift
count is given by the low-order six bits of the second operand (second
operand & 0x3f).
0x1f = 31
et donc 32 et ses multiples valent 0 comme 2ème opérateur quand le
premier opérateur est int32...
Ma question est simple : pourquoi 1 décalé à droite de n'importe quel multiple de 32 donne 1, et 0 pour toutes les autres valeurs ? J'utilise C#2. Normalement le décalage fait tomber les bits qui dépassent dans l'oubli, et comble les nouveaux avec des zéros non ?
D'après la doc:
If the first operand is an int or uint (32-bit quantity), the shift count is given by the low-order five bits of the second operand (second operand & 0x1f).
If the first operand is a long or ulong (64-bit quantity), the shift count is given by the low-order six bits of the second operand (second operand & 0x3f).
0x1f = 31 et donc 32 et ses multiples valent 0 comme 2ème opérateur quand le premier opérateur est int32...
zoltix
Antoine Polatouche a écrit :
Vivien Parlat a écrit :
Bonjour,
Ma question est simple : pourquoi 1 décalé à droite de n'importe quel multiple de 32 donne 1, et 0 pour toutes les autres valeurs ? J'utilise C#2. Normalement le décalage fait tomber les bits qui dépassent dans l'oubli, et comble les nouveaux avec des zéros non ?
D'après la doc:
If the first operand is an int or uint (32-bit quantity), the shift count is given by the low-order five bits of the second operand (second operand & 0x1f).
If the first operand is a long or ulong (64-bit quantity), the shift count is given by the low-order six bits of the second operand (second operand & 0x3f).
0x1f = 31 et donc 32 et ses multiples valent 0 comme 2ème opérateur quand le premier opérateur est int32...
j'ai pas bien compris.............
Antoine Polatouche a écrit :
Vivien Parlat a écrit :
Bonjour,
Ma question est simple : pourquoi 1 décalé à droite de n'importe
quel multiple de 32 donne 1, et 0 pour toutes les autres valeurs ?
J'utilise C#2. Normalement le décalage fait tomber les bits qui
dépassent dans l'oubli, et comble les nouveaux avec des zéros non ?
D'après la doc:
If the first operand is an int or uint (32-bit quantity), the shift
count is given by the low-order five bits of the second operand (second
operand & 0x1f).
If the first operand is a long or ulong (64-bit quantity), the shift
count is given by the low-order six bits of the second operand (second
operand & 0x3f).
0x1f = 31
et donc 32 et ses multiples valent 0 comme 2ème opérateur quand le
premier opérateur est int32...
Ma question est simple : pourquoi 1 décalé à droite de n'importe quel multiple de 32 donne 1, et 0 pour toutes les autres valeurs ? J'utilise C#2. Normalement le décalage fait tomber les bits qui dépassent dans l'oubli, et comble les nouveaux avec des zéros non ?
D'après la doc:
If the first operand is an int or uint (32-bit quantity), the shift count is given by the low-order five bits of the second operand (second operand & 0x1f).
If the first operand is a long or ulong (64-bit quantity), the shift count is given by the low-order six bits of the second operand (second operand & 0x3f).
0x1f = 31 et donc 32 et ses multiples valent 0 comme 2ème opérateur quand le premier opérateur est int32...
j'ai pas bien compris.............
Antoine Polatouche
zoltix a écrit :
Antoine Polatouche a écrit :
Vivien Parlat a écrit :
Bonjour,
Ma question est simple : pourquoi 1 décalé à droite de n'importe quel multiple de 32 donne 1, et 0 pour toutes les autres valeurs ? J'utilise C#2. Normalement le décalage fait tomber les bits qui dépassent dans l'oubli, et comble les nouveaux avec des zéros non ?
D'après la doc:
If the first operand is an int or uint (32-bit quantity), the shift count is given by the low-order five bits of the second operand (second operand & 0x1f).
If the first operand is a long or ulong (64-bit quantity), the shift count is given by the low-order six bits of the second operand (second operand & 0x3f).
0x1f = 31 et donc 32 et ses multiples valent 0 comme 2ème opérateur quand le premier opérateur est int32...
j'ai pas bien compris.............
Quand le premier opérande est un int32, le décalage n'est pas donné par le second opérande, mais par ce second opérande & 0x1f. Seuls les 5 bits de poids faible du second opérande sont utilisés pour le décalage. En d'autres termes, le décalage maximum est de 31 = 0x1f = 11111 en binaire. pour 32 et ses multiples, les 5 bits de poids faible sont égal à 0, donc pas de décalage et résultat = 1.
zoltix a écrit :
Antoine Polatouche a écrit :
Vivien Parlat a écrit :
Bonjour,
Ma question est simple : pourquoi 1 décalé à droite de n'importe
quel multiple de 32 donne 1, et 0 pour toutes les autres valeurs ?
J'utilise C#2. Normalement le décalage fait tomber les bits qui
dépassent dans l'oubli, et comble les nouveaux avec des zéros non ?
D'après la doc:
If the first operand is an int or uint (32-bit quantity), the shift
count is given by the low-order five bits of the second operand (second
operand & 0x1f).
If the first operand is a long or ulong (64-bit quantity), the shift
count is given by the low-order six bits of the second operand (second
operand & 0x3f).
0x1f = 31
et donc 32 et ses multiples valent 0 comme 2ème opérateur quand le
premier opérateur est int32...
j'ai pas bien compris.............
Quand le premier opérande est un int32, le décalage n'est pas donné par
le second opérande, mais par ce second opérande & 0x1f. Seuls les 5 bits
de poids faible du second opérande sont utilisés pour le décalage. En
d'autres termes, le décalage maximum est de 31 = 0x1f = 11111 en binaire.
pour 32 et ses multiples, les 5 bits de poids faible sont égal à 0, donc
pas de décalage et résultat = 1.
Ma question est simple : pourquoi 1 décalé à droite de n'importe quel multiple de 32 donne 1, et 0 pour toutes les autres valeurs ? J'utilise C#2. Normalement le décalage fait tomber les bits qui dépassent dans l'oubli, et comble les nouveaux avec des zéros non ?
D'après la doc:
If the first operand is an int or uint (32-bit quantity), the shift count is given by the low-order five bits of the second operand (second operand & 0x1f).
If the first operand is a long or ulong (64-bit quantity), the shift count is given by the low-order six bits of the second operand (second operand & 0x3f).
0x1f = 31 et donc 32 et ses multiples valent 0 comme 2ème opérateur quand le premier opérateur est int32...
j'ai pas bien compris.............
Quand le premier opérande est un int32, le décalage n'est pas donné par le second opérande, mais par ce second opérande & 0x1f. Seuls les 5 bits de poids faible du second opérande sont utilisés pour le décalage. En d'autres termes, le décalage maximum est de 31 = 0x1f = 11111 en binaire. pour 32 et ses multiples, les 5 bits de poids faible sont égal à 0, donc pas de décalage et résultat = 1.
