Bien que la réponse acceptée souligne que l'endianess est un concept du point de vue de la mémoire. Mais je ne pense pas que cela réponde directement à la question.
Certaines réponses me disent que les opérations au niveau du bit ne dépendent pas de l'endianess , et le processeur peut représenter les octets de toute autre manière. Quoi qu'il en soit, il parle de cette endianess est abstraite.
Mais lorsque nous faisons des calculs au niveau du bit sur le papier, par exemple, vous n'avez pas besoin de déclarer l'endianess en premier lieu? La plupart du temps, nous choisissons implicitement une fin.
Par exemple, supposons que nous ayons une ligne de code comme celle-ci
0x1F & 0xEF
Comment calculeriez-vous le résultat à la main, sur un papier?
MSB 0001 1111 LSB
1110 1111
result: 0000 1111
Nous utilisons donc ici un format Big Endian pour faire le calcul. Vous pouvez également utiliser Little Endian pour calculer et obtenir le même résultat.
Btw, quand nous écrivons des nombres dans le code, je pense que c'est comme un format Big Endian. 123456
ou 0x1F
, les nombres les plus significatifs commencent par la gauche.
Encore une fois, dès que nous écrivons un format binaire d'une valeur sur le papier, je pense que nous avons déjà choisi une Endianess et nous regardons la valeur telle que nous la voyons dans la mémoire.
Revenons donc à la question, une opération de décalage <<
devrait être considérée comme un passage de LSB (octet le moins significatif) à MSB (octet le plus significatif) .
Puis comme pour l'exemple dans la question:
numb=1025
Petit endian
LSB 00000001 00000100 00000000 00000000 MSB
Ce << 10
serait donc 10bit
passer du LSB au MSB.
Comparaison et << 10
opérations pour le format Little Endian étape par étape:
MSB LSB
00000000 00000000 00000100 00000001 numb(1025)
00000000 00010000 00000100 00000000 << 10
LSB MSB
00000000 00000100 00010000 00000000 numb(1025) << 10, and put in a Little Endian Format
LSB MSB
00000001 00000100 00000000 00000000 numb(1205) in Little Endian format
00000010 00001000 00000000 00000000 << 1
00000100 00010000 00000000 00000000 << 2
00001000 00100000 00000000 00000000 << 3
00010000 01000000 00000000 00000000 << 4
00100000 10000000 00000000 00000000 << 5
01000000 00000000 00000001 00000000 << 6
10000000 00000000 00000010 00000000 << 7
00000000 00000001 00000100 00000000 << 8
00000000 00000010 00001000 00000000 << 9
00000000 00000100 00010000 00000000 << 10 (check this final result!)
Hou la la! J'obtiens le résultat attendu comme décrit par l'OP!
Les problèmes que l'OP n'a pas obtenu le résultat attendu sont les suivants:
Il semble qu'il ne soit pas passé du LSB au MSB.
Lorsque vous déplacez des bits au format Little Endian, vous devez vous rendre compte (dieu merci, je le réalise) que:
LSB 10000000 00000000 MSB << 1
est
LSB 00000000 00000001 MSB
, pas
LSB 01000000 00000000 MSB
Parce que pour chaque individu 8bits
, nous l'écrivons en fait dans un MSB 00000000 LSB
format Big Endian.
Alors c'est comme
LSB[ (MSB 10000000 LSB) (MSB 00000000 LSB) ]MSB
Pour résumer:
Bien que l'on dit que les opérations au niveau du bit sont abstraites blablablabla ..., lorsque nous calculons les opérations au niveau du bit à la main, nous avons encore besoin de savoir quelle extrémité nous utilisons lorsque nous écrivons le format binaire sur le papier. Nous devons également nous assurer que tous les opérateurs utilisent la même finalité.
L'OP n'a pas obtenu le résultat escompté parce qu'il a mal agi.