Problème de compréhension sur opérateur binaire pour reconstituer un entier.
Bonjour, mon code marche mais je n'arrive pas à comprendre le principe de fonctionnement de
cette ligne de code : z = d<<24 | c<<16 | b<<8 | a;
je suis en LITTLE-ENDIAN donc int n=16 777 643 (j'ai pris un grand nombre pour l'exemple)
s'écrit en bit comme ça :
1010 1011 0000 0001 0000 0000 000 0001
Après avoir ranger chaque octet dans un char j'obtiens ceci :
a=1010 1011
b=0000 0001
c=0000 0000
d=0000 0001
Je vous explique comment j'ai compris cette ligne : z = d<<24 | c<<16 | b<<8 | a;
Je suppose ici que le compilateur commence par lire les instructions à gauche donc on décale d
de 24 bits vers la gauche le problème c'est que je trouve cette instruction illogique car pour moi, un
char fait 1 octet donc 8 bits si je décale de 24 bits vers la gauche logiquement je perds mes bits
puisque 1 char fait 8 bits si je décale de 24 bits donc logiquement d vaudra zéro et le 1 sera
perdu ; idem pour c et b (Si je prends b qui vaut 000 0001 aussi si je le décale de 8 bits le 1 sort du chant de bits du char b).
Ensuite on nous dit de comparer d décalé de 24 bits à c décalé de 16 bit si on compare 2 char
avec l'opérateur OU logiquement je devrait avoir ça :
d = 0000 0001 si on décale : d<<24 donne : 0000 0000 on sort du char d nos bits son perdu
c = 0000 0000 si on décale : c<<16 donne : 0000 0000 on sort du char c nos bits son perdu
On applique l'opérateur OU : d<<24 | c<<16 donne : 0000 0000 je met pas la suite et au final on met le résultat final dans z ; voilà comment j'ai compris la chose, pourtant ce n'est pas comme ça que cette ligne fonctionne et pourtant le résultat renvoyer dans z correspond à ma valeur n.
On devrait plutôt faire comme ceci :
-------------d
int z=d : 0000 0001 0000 0000 0000 0000 0000 0000 (on met d dans z)
------------------------d
z=z<<8 : 0000 0000 0000 0001 0000 0000 0000 0000 (on décale de 8 bits vers la gauche)
c------: 0000 0000 (valeur de c)
------------c---------d
z=z|c : 0000 0000 0000 0001 0000 0000 0000 0000 (Résultat du OU Binaire)
------------------------c----------d
z=z<<8 : 0000 0000 0000 0000 0000 0001 0000 0000 (on décale de 8 bits vers la gauche)
b-------: 0000 0001 (valeur de b)
------------b----------c---------d
z=z|b : 0000 0001 0000 0000 0000 0001 0000 0000 (Résultat du OU Binaire)
------------------------b----------c---------d
z=z<<8 : 0000 0000 0000 0001 0000 0000 0000 0001 (on décale de 8 bits vers la gauche)
a-------: 1010 1011 (valeur de a)
------------a----------b---------c---------d
z=z|a : 1010 1011 0000 0001 0000 0000 0000 0001 (Résultat du OU Binaire)
En résumé :
z=d;
z=z<<8;
z=z|c;
z=z<<8;
z=z|b;
z=z<<8;
z=z|a;
Ce qui est ci-dessus est pour moi logique alors que cette ligne là : z = d<<24 | c<<16 | b<<8 | a; ne
l'est pas du tout puisque l'on décale des char et on les compare ensembles alors que l'on devrait
mettre les char dans l'entier z au fur et à mesure qu'on les décales on met le premier char d dans
z, z qu'on décale ensuite on compare z avec le 2eme char on décale etc...
Si quelqu'un pouvait m'expliquer cette ligne de code z = d<<24 | c<<16 | b<<8 | a;.
Merci par avance.
Je vous met le code en entier.
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
int n=427;
int z=0;
unsigned char a, b, c, d;
a=n&255;
b=n>>8&255;
c=n>>16&255;
d=n>>24;
printf("a=%d b=%d c=%d d=%d\n",a,b,c,d);
/*z=d;
z=z<<8;
z=z|c;
z=z<<8;
z=z|b;
z=z<<8;
z=z|a;*/
z = d<<24 | c<<16 | b<<8 | a;
printf("z=%d", z);
return EXIT_SUCCESS;
} |
