Discussion :

[cirdan_elf]

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.

[diogene]

La conversion d'une valeur d'un type entier T1 en un autre type entier T2 est assez complexe :

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
1 - Si la valeur (de type T1) peut être représentée par le nouveau type T2:
    la valeur est inchangée (seul le type change).

   (Dans le cas signé -> non signé ce ne peut pas être le cas des valeurs négatives)

2 - Sinon,deux cas selon que T2 est un type signé ou non :

     2-a si T2 est un type non signé, la règle est claire :
           La nouvelle valeur est obtenue par ajout ou soustraction de la valeur
           maximum +1 du type non signé T2 jusqu'à obtenir une valeur dans la
           plage du type T2.

          Par exemple, avec T2 sur 8 bits, la valeur -2 deviendra la valeur 254 (= -2+256)
          (On peut remarquer que dans le cas d'entiers signés en complément à 
           2, la configuration des bits n'a pas changée si T1 et T2 ont même 
           largeur, mais pour le complément à 1 ou le code signe/valeur absolue
           elle est différente.)

    2-b  Si T2 est un type signé, le résultat est défini par l'implémentation et
           est donc non portable.

Si pour l'émission, on sait bien ce qui se passe avec un cast (puisque vers un type non signé), à la réception, le comportement du cast (vers un type signé) dépendra de l'implémentation.