Que fait un décalage binary (gauche ou droit) et à quoi sert-il?

J’ai vu les opérateurs >> et << dans divers codes que j’ai consultés (aucun de ceux que j’ai réellement compris), mais je me demande ce qu’ils font réellement et quelles sont leurs utilisations pratiques.

MODIFIER

Si les décalages sont comme x * 2 et x / 2 , quelle est la différence réelle entre les opérateurs * et / ? Y a-t-il une différence de performance?

    Voici une applet où vous pouvez exercer certaines opérations sur les bits, y compris le décalage.

    Vous avez une collection de bits et vous en déplacez certains au-delà de leurs limites:

     1111 1110 << 2 1111 1000 

    il est rempli de plein droit avec des zéros frais. 🙂

     0001 1111 >> 3 0000 0011 

    rempli de gauche. Un cas particulier est le premier. Il indique souvent une valeur négative - en fonction de la langue et du type de données. Si souvent, si vous changez de position, le premier rest tel quel.

     1100 1100 >> 1 1110 0110 

    et il est conservé sur plusieurs quarts de travail:

     1100 1100 >> 2 1111 0011 

    Si vous ne voulez pas que le premier bit soit préservé, vous utilisez (en Java, Scala, C ++, C afaik, et peut-être plus) un opérateur de sortingple-signe:

     1100 1100 >>> 1 0110 0110 

    Il n'y a pas d'équivalent dans l'autre sens, car cela n'a aucun sens - peut-être dans votre contexte très particulier, mais pas en général.

    Mathématiquement, un décalage à gauche est un * = 2, 2 décalages à gauche est un * = 4 et ainsi de suite. Un décalage à droite est a / = 2 et ainsi de suite.

    Le bit de gauche se décale pour multiplier par toute puissance de deux et le bit de droite se décale pour diviser par toute puissance de deux. Par exemple x = x * 2; peut également être écrit comme x<<1 ou x = x*8 peut être écrit comme x<<3 (puisque 2 à la puissance de 3 est 8). De même x = x / 2; est x>>1 et ainsi de suite.

    Décalage à gauche

    x = x * 2^value (fonctionnement normal)

    x << value (opération par bit)


    x = x * 16 (identique à 2^4 )

    L’équivalent gauche serait x = x << 4

    Droite changement

    x = x / 2^value (opération arithmétique normale)

    x >> value (opération par bit)


    x = x / 8 (identique à 2^3 )

    L'équivalent du décalage vers la droite serait x = x >> 3

    Décalage à gauche : Il est égal au produit de la valeur qui doit être déplacé et 2 élevé à la puissance du nombre de bits à déplacer.

    Exemple :

     1<<3 0000 0001 ---> 1 Shift by 1 bit 0000 0010 ----> 2 which is equal to 1*2^1 Shift By 2 bits 0000 0100 ----> 4 which is equal to 1*2^2 Shift by 3 bits 0000 1000 ----> 8 which is equal to 1*2^3 

    Décalage à droite : Il est égal au quotient de valeur qui doit être décalé de 2 et porté à la puissance du nombre de bits à déplacer.

    Exemple :

     8>>3 0000 1000 ---> 8 which is equal to 8/2^0 Shift by 1 bit 0000 0100 ----> 4 which is equal to 8/2^1 Shift By 2 bits 0000 0010 ----> 2 which is equal to 8/2^2 Shift by 3 bits 0000 0001 ----> 1 which is equal to 8/2^3 

    Les opérateurs de décalage binary sont plus efficaces que les opérateurs / ou *. Dans l’architecture informatique, diviser (/) ou multiplier (*) prend plus d’une unité de temps et s’enregistrer pour calculer le résultat, alors que l’opérateur de décalage binary est juste un calcul d’unité et une unité d’unité.

    Bit de gauche changeant pour se multiplier par n’importe quelle puissance de deux. Bit de droite changeant pour diviser par n’importe quelle puissance de deux.

     x = x << 5; // Left shift y = y >> 5; // Right shift 

    En C / C ++ il peut être écrit comme,

     #include  x = x * pow(2, 5); y = y / pow(2, 5); 

    Quelques exemples:

    • Opérations sur les bits, par exemple, conversion vers et depuis la base64 (6 bits au lieu de 8)
    • faire le pouvoir de 2 opérations ( 1 << 4 égal à 2^4 soit 16)
    • Écrire du code plus lisible lorsque vous travaillez avec des bits. Par exemple, la définition de constantes à l'aide de 1 << 4 ou 1 << 5 est plus lisible.

    Oui, je pense que vous pourriez trouver une différence en termes de performances car les opérations de décalage gauche et droite au niveau du bit peuvent être effectuées avec une complexité de o (1) avec un jeu de données énorme.

    Par exemple, puissance de calcul de 2 ^ n: –

     int value = 1; while (exponent 

    Un code similaire avec une opération de décalage gauche au niveau du bit serait comme suit:

     value = 1 << n; 

    De plus, l'exécution d'un fonctionnement par bit est comme une réplique exigeante des opérations mathématiques de niveau utilisateur (qui sont les instructions finales de niveau machine traitées par le micro-contrôleur et le processeur).

    Voici un exemple:

     #include"stdio.h" #include"conio.h" void main() { int rm,vivek; clrscr(); printf("enter the any numbers\t(eg)1,2,5"); scanf("%d",&rm);//rm=5(0101)<<2(two step add zero's)so,value is 10100 printf("this lift shitf value%d=%d",rm,rm<<4); printf("this right shitf value%d=%d",rm,rm>>2); getch(); }