Main

Référence : Langage Arduino : [ Mini | Standard | Etendue | Maxi ] Librairies : [ Vue d'ensemble | Synthèse ] Infos : [ Comparaison | Changements ]

Décalage des bits vers la gauche (<<), Décalage des bits vers la droite(>>)


Cette page est issue du Tutoriel sur les math binaires du "terrain de jeux".

Description

Il y a deux opérateurs de décalage de bits en langage C++ : l'opérateur de décalage à gauche << et l'opérateur de décalage à droite >>. Ces opérateurs entraîne le décalage des bits vers la droite ou vers la gauche de l'expression entière située à gauche de l'opérateur d'un nombre de positions spécifié par l'expression numérique entière de droite.

Davantage d'information sur les math binaires peuvent être trouvés ici : Tutoriel sur les math binaires du "terrain de jeux".

Syntaxe


variable << nombre_de_bits

variable >> nombre_de_bits
 

Paramètres

  • variable : une variable de type entier (byte, int, long)
  • nombre_de_bits : nombre entier <= 32, correspondant au nombre de bits à décaler.

Exemples

    int a = 5;        // binaire: 0000000000000101
    int b = a << 3;   // binaire: 0000000000101000, ou 40 en décimal
    int c = b >> 3;   // binaire: 0000000000000101, ou retour à 5

Lorsque vous décalez une valeur x de y bits (x<<y), les y bits les plus élevés sont perdus, litéralement décalés hors de l'existence.

    int a = 5;        // binary: 0000000000000101
    int b = a << 14;  // binary: 0100000000000000 - the first 1 in 101 was discarded

Si vous êtes certain qu'aucun des bits d'une valeur ne soient décalés dans l'oubli (voir ci-dessus), une façon simple de concevoir l'opérateur de décalage à gauche est qu'il multiplie l'expression numérique entière à sa gauche par 2 élevé à la puissance de la valeur numérique à droite. Par exemple, pour générer les puissances de 2, les expressions suivantes peuvent être employées :

    1 <<  0  ==    1
    1 <<  1  ==    2
    1 <<  2  ==    4
    1 <<  3  ==    8
    ...
    1 <<  8  ==  256
    1 <<  9  ==  512
    1 << 10  == 1024
    ...

Quand vous décalez x de y bits vers la droite (x>>y), et que le bit le plus fort de x est 1, le comportement dépend du type exact de donnée de x. Si x est de type int, le bit le plus fort est le bit de signe, déterminant si x est négative ou non, comme discuté auparavant. Dans ce cas, le bit de signe est copié (sans être lui-même modifié) dans les bits de poids inférieurs, pour des raisons historiques mystérieuses :

    int x = -16;     // binary: 1111111111110000
    int y = x >> 3;  // binary: 1111111111111110

Ce comportement, appelé "extension du signe", n'est souvent pas le comportement que vous souhaitez. Au lieu de cela, vous voudriez plutôt que des 0 soient décalés depuis la gauche. En considérant que le fonctionnement du décalage vers la droite est différent pour les expressions de type int non signées, vous pouvez utiliser un type de donnée qui supprime les bits copiés depuis la gauche :

    int x = -16;                   // binary: 1111111111110000
    int y = (unsigned int)x >> 3;  // binary: 0001111111111110

Si vous faîtes attention d'éviter le mécanisme "d'extension de signe", vous pouvez utiliser l'opérateur de décalage vers la droite >> comme une façon de diviser par des puissances de 2. Par exemple :

    int x = 1000;
    int y = x >> 3;   // integer division of 1000 by 8, causing y = 125.

Commentaires utilisateurs

  • Une utilisation intéressante des décalages : les jeux de lumières à LED.

Page d'accueil de la référence Arduino en français

Corrections, suggestions et nouvelle documentation peuvent être postées sur le Forum Arduino ou à l'adresse suivante : support_at_mon-club-elec_point_fr

Le texte original de la référence Arduino est sous licence Creative Commons Attribution-ShareAlike 3.0 . Les exemples de code dans la référence sont dans le domaine public.

La présente traduction française commentée a été réalisée par Xavier HINAULT (2010-2012) (www.mon-club-elec.fr) et est sous licence Creative Commons Attribution-ShareAlike 3.0.