Bonjour,

imaginons que je veuille envoyer un entier signé par le réseau, et que la machine en réception sache quelle est ma représentation utilisée (je ne parle pas encore d'endianness mais de complément à deux etc...).

Si je veux envoyer avec le MSB en premier, est-ce que je peux convertir mon signé en non signé et ensuite convertir en prenant compte l'endianness ?

En reprenant l'exemple d'Emmanuel Delahaye ici : http://emmanuel-delahaye.developpez....-reseaux-c/#LV, ça ferait :

Emetteur :

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
 
{
   /* donnée a transmettre */
   signed long machin = -2;
   unsigned long u_machin = (unsigned long) machin;
 
   /* donnees effectivement transmises */
   unsigned char data[4];
 
   data[0] = (u_machin >> (3 * 8)) & 0xFF; /* MSB (3) en tete (0) */
   data[1] = (u_machin >> (2 * 8)) & 0xFF;
   data[2] = (u_machin >> (1 * 8)) & 0xFF;
   data[3] = (u_machin >> (0 * 8)) & 0xFF;
 
   /* transmission du bloc : */
   int n = send (sock, data, sizeof data, 0);
 
   if (n > 0)
   {
      /* transmission reussie */
   }
   else
   {
      /* echec de la transmission */
   }
}
Le récepteur ferait :

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
 
{
   /* donnees 'taille' effectivement reçues */
   unsigned char data[4];
 
   /* reception du bloc : */
   int n = recv (sock, data, sizeof data, 0);
 
   if (n == sizeof data)
   {
      /* reception reussie */
      /* donnée a recevoir */
      unsigned long u_machin = 0;
 
      u_machin |= (data[0] << (3 * 8)) ; /* MSB (3) en tete (0) */
      u_machin |= (data[1] << (2 * 8)) ;
      u_machin |= (data[2] << (1 * 8)) ;
      u_machin |= (data[3] << (0 * 8)) ;
 
      printf ("ma donnée signée = %l\n", (signed long)u_machin);
 
   }
   else
   {
      /* echec de la reception */
   }
}
C'est OK ? (Si les deux machines ont la même représentation des signés ?)

En fait, d'une façon générale, est-ce qu'un cast signé -> non signé du même type peut faire perdre des informations sur les bits du nombre signé ?


Edition : reformulation.