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 : Sélectionner tout - Visualiser dans une fenêtre à part
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;
}