Les opérateurs de décalage de bits à faire exactement ce que leur nom l'indique. Ils décalage de bits. Voici un petit (ou pas si brève) présentation des différents opérateurs de décalage.
Les Opérateurs
-
>>
est la moyenne (ou signé) décalage à droite de l'opérateur.
-
>>>
est la logique (ou non signé) décalage à droite de l'opérateur.
-
<<
est le décalage à gauche de l'opérateur, et qui répond aux besoins à la fois de logique et de l'arithmétique des quarts de travail.
Tous ces opérateurs peuvent être appliqués à des valeurs entières (int
, long
,, éventuellement, short
et byte
ou char
). Dans certaines langues, en appliquant les opérateurs de décalage à tout type de données plus petit que int
redimensionne automatiquement l'opérande à un int
.
Notez que <<<
n'est pas un opérateur, parce que ce serait redondant. Notez également que le C et le C++ ne pas distingiush entre le droit d'opérateurs de décalage. Ils fournissent seulement l' >>
de l'opérateur, et le décalage de comportement est définie par l'implémentation.
Décalage vers la gauche (<<)
Les entiers sont stockés dans la mémoire, comme une série de bits. Par exemple, le nombre 6 stockées en 32 bits int
serait:
00000000 00000000 00000000 00000110
L'évolution de cette séquence de bits vers la gauche d'une position (6 << 1
) aurait pour conséquence le nombre de 12:
00000000 00000000 00000000 00001100
Comme vous pouvez le voir, les chiffres ont décalé vers la gauche par une position, et le dernier chiffre à droite est rempli avec un zéro. Vous pouvez également noter que le passage de gauche est équivalent à une multiplication par des puissances de 2. Donc, 6 << 1
est équivalent à 6 * 2
, et 6 << 3
est équivalent à 6 * 8
. Une bonne optimisation du compilateur remplacera changements pour les multiplications lorsque cela est possible.
Non circulaire déplacement
Veuillez noter que ce ne sont pas circulaire quarts de travail. L'évolution de cette valeur à la gauche d'une position (3,758,096,384 << 1
):
11100000 00000000 00000000 00000000
résultats dans 3,221,225,472:
11000000 00000000 00000000 00000000
Les chiffres qui obtient décalé "à la fin" est perdu. Il n'est pas autour.
Logique décalage à droite (>>>)
Une logique décalage à droite est l'inverse pour le décalage à gauche. Plutôt que de déplacer des bits vers la gauche, il suffit de déplacer vers la droite. Par exemple, passer le nombre de 12:
00000000 00000000 00000000 00001100
à la droite d'une position (12 >>> 1
) de revenir a l'origine, notre 6:
00000000 00000000 00000000 00000110
Nous voyons donc que se décalant sur la droite est l'équivalent de la division par puissances de 2.
Perdu les bits sont allés
Toutefois, un changement ne peut pas récupérer la "perte" de bits. Par exemple, si l'on passe ce modèle:
00111000 00000000 00000000 00000110
à la gauche de la 4 positions (939,524,102 << 4
), nous obtenons 2,147,483,744:
10000000 00000000 00000000 01100000
et puis le retour ((939,524,102 << 4) >>> 4
) nous obtenons 134,217,734:
00001000 00000000 00000000 00000110
Nous ne pouvons pas revenir notre valeur d'origine une fois que nous avons perdu bits.
L'arithmétique décalage à droite (>>)
L'arithmétique décalage à droite est exactement comme la logique décalage à droite, sauf qu'au lieu de rembourrage à zéro, il remplit avec le bit le plus significatif. C'est parce que le bit le plus significatif est le signe bits, ou le peu qui distingue les nombres positifs et négatifs. Par remplissage avec le bit le plus significatif, l'arithmétique décalage à droite est le signe de la préservation de.
Par exemple, si nous interprétons cette séquence de bits comme un nombre négatif:
10000000 00000000 00000000 01100000
nous avons le nombre -2,147,483,552. L'évolution de cette à la droite de 4 positions avec le décalage (-2,147,483,552 >> 4) nous donnerait:
11111000 00000000 00000000 00000110
ou le nombre -134,217,722.
Nous voyons donc que nous avons conservé le signe des nombres négatifs en utilisant l'arithmétique des maj de droite, plutôt que de la logique décalage à droite. Et encore une fois, nous voyons que nous sommes en effectuant la division par puissances de 2.