Discussion :

[boboss123]

Bonjour,

j'ai les variables suivantes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
unsigned char buf[2];
int val; // entier signé sur deux octets

Je voudrais copier la valeur qui est dans buff[] dans la variable val.
buff[0] contient l'octet de poids fort et buff[1] contient l'octet de poids faible.

Comment dois-je vais ma copie ?

comme ça ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
val =  buf[1];
val |=  ((int)buf[0]) << 8;

J'ai quelque doute sur le castage : si buf[0] = 0xFF, alors ((int)buf[0]), ça donne quoi ? 255 ou -127 ?

Quelles sont les règles pour le castage au niveau du signe ?

[6-MarViN]

Je m'egare peut-etre mais ne pourrais tu pas stocker ces variable dans une union? Vu qu'elle auront la meme adresse, tu pourras acceder aux valeurs de ton tableau via ton int...

[matafan]

Dans ton exemple ((int)buf[0]) sera un int qui vaudra 255.

Par contre si buf[] avait été déclaré en "signed char", ((int)buf[0]) aurait valu -1 (c'est à dire, en hexa, 0xffffffff). C'est le "signedness" de buf[] qui va déterminer comment le signe est "expansé" lors du cast.

[boboss123]

merci,

Ma fonction doit donc bien fonctionner...

Par contre que se passe t-il sur ces deux cas ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
unsigned char myChar;
signed char mySChar;
 
mySChar = -1;
myChar = (unsigned char)mySChar; // ???
 
myChar = 255;
mySChar= (signed char)myChar ; // ???
 
// copie de la valeur hexa
myChar = 255;
mySChar = myChar; // comment faire pour que le compilateur ne fasse pas de warning ?

[diogene]

Pour des char de 8 bits :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
mySChar = -1;
myChar = (unsigned char)mySChar; // ???

myChar = 256+mySChar = 255

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
myChar = 255;
mySChar= (signed char)myChar ; // ???

mySChar dépend de l'implémentation

Pour revenir au premier post :

Dans l'expression buf[0] << 8, l'opérande buf[0] est promu en int automatiquement (donc le cast est inutile) en conservant sa valeur.
Si les int de la machine sont sur plus de 16 bits, cette expression est égale à buf[0]*256.
Par exemple, si on a unsigned char buf[2]= {0xA4,0xe3} = {164,227}, buf[0]) << 8 a pour valeur 164*256 = 41984.
et au total, le code posté donnera val = buf[0]*256+buf[1] soit dans l'exemple 41984+227 = 42211 (ce qui n'est pas la valeur espérée).
Si les int sont sur 16 bits, alors le résultat de buf[0]<< 8 peut n'être pas représentable par un int (pour buf[0] >127) et dans ce cas le comportement est indéfini .

Manipuler les bits impose de connaitre la représentation interne des nombres signés : complément à 2 ou autre chose (pas fréquent), ordre des bytes msb->lsb ou lsb->msb (les deux sont fréquents) ou autre (rare). Même en se limitant aux cas fréquents, on a deux options pour cette représentation : complément à 2 + msb->lsb et complément à 2 + lsb->msb . On a donc intérêt à chercher une méthode plus abstraite indépendante de la représentation interne à obtenir.

Si buf[] est censé représenter un nombre entier en complément à 2 avec buf[0] comme poids fort, on peut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

val = buf[1] +  (buf[0]>127 ? (buf[0]-256)*256 : buf[0]*256);

qui donnera dans l'exemple val = -23325;

Le résultat est alors indépendant de la représentation interne à la machine des nombres signés (c'est une méthode calculant la valeur d'un nombre dont on connait la représentation en complément à 2) et doit marcher si les int ont 16 bits minimum (les termes de l'expression tenant sur 16 bits signés).

[boboss123]

merci pour les explications

Par contre je n'ai pas compris où était le problème pour ça :

Si les int sont sur 16 bits, alors le résultat de buf[0]<< 8 peut n'être pas représentable par un int (pour buf[0] >127) et dans ce cas le comportement est indéfini .

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
unsigned char buf[2]
signed int val;
// val = -22015
buf[0] = 0b10101010;
buf[1] = 0b00000001;
val = (buf[0] << 8) + buf[1];

si on décompose, ça donne (si on est en complément A2)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
1- buf[0] est automatiquement casté en int 16 bits => 0b00000000 10101010;
2- le décalage de bit est effectué => 0b10101010 00000000;
3- buf[1] est automatiquement casté en int 16 bits => 0b00000000 00000001;
4- les valeurs sont additionnées 0b10101010 00000000 + 0b00000000 00000001 = 0b10101010 00000001 = -22015

=> je ne vois pas ou il y a de risque de problème

sinon, est-ce que vous connaissez un bon tuto complet qui explique comment sont évaluées/castées les expressions en C ?