Discussion :

[Biosox]

Bonjour.

que se passe-t'il si j'écris:

Code :

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

1
2
 
unsigned int i = -1;

Est-ce que ça va poser un problème?
en tout cas le compilateur l'accepte et ça a l'air de marcher.

je m'explique:
je veux écrire une fonction dont la valeur de retour est supposée être un entier positif (par exemple une fonction qui calcule une distance... une distance ça ne peut pes être négatif par définition. du coup ma fonction va retourner un unsigned int

Code :

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

unsigned int calcul_distance();

si il y a une erreur dans ma fonction, ça m'arrange de retourner une valeur du genre -1, -2, etc... (si mes int sont codés sur 32 bits, si je retourne -1, ça va en fait retourner 0xffffffff, soit 4 milliards et des poussières... c'est une "distance" que je peux raisonnablement considerer comme fausse)

que va-til se passer avec le code:

Code :

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

1
2
3
4
5
6
 
unsigned int d = 0;
d = calcul_distance();
if(d == -1){
printf("error");
}

il compile et il marche... j'ai même pas de warning pour la comparaison entre 'd' et '-1'
Mais je me pose la question: Est-ce que ça va marcher avec tous les compilos?
Et si oui, a quoi ça sert d'avoir 2 types distinct (int et unsigned int) alors que visiblement ils sont traités pareil?

merci!

a+

[Jenna]

Compilateur mal réglé, normallement, il devrait crier et emettre au moins un warning en disant en substance "comparaison entre un nombre signé et un nombre non signé".

A quoi cela sert d'avoir 2 type distincts, pour les traiter différemment.

essaye

Code :

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

1
2
unsigned int test1 = -2;
test1 <<= 1;

et

Code :

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

1
2
int test1 = -2;
test1 <<= 1;

tu auras 2 résultats différents.

[Biosox]

Bonjour,
merci pour ta répnse.
Qu'entends-tu par résultats différents?

J'ai fait:

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
int main()
{
  unsigned int test1 = -2;
  int test2 =-2;
 
  test1 <<= 1;
  test2 <<= 1;
 
  printf("test1  %08X  %d  %u\n", test1, test1, test1);
  printf("test2  %08X  %d  %u\n", test2, test2, test2);
 
  if( test1 < test2 ){
    printf("smaller\n");
  }
 
  if( test1 > test2 ){
    printf("bigger\n");
  }
 
  if( test1 == test2 ){
    printf("equal\n");
  }
 
  return 0;
}

et mon output:

test1 FFFFFFFC -4 4294967292
test2 FFFFFFFC -4 4294967292
equal

Bon... je suppose que printf fait un cast si je lui donne un unsigned pour un %d, et inversément... mais le 0x08X semble montrer que les 2 variables sont traitées de la même façon, non?

[Jenna]

dans le 1er cas (unsigned int), la nouvelle valeur est 4294967292
dans le 2ème cas (int), la nouvelle valeur est -4

donc 2 valeurs sémantiquement différentes (même si leur représentation en mémoire est identique)

au passage, j'ai un warning du compilateur

warning C4245: 'initialisation' : conversion de 'int' en 'unsigned int', incompatibilité signed/unsigned

[Biosox]

merci pour ces précisions.
je vais essayer de voir pourquoi j'ai pas de warnings de mon coté.

[diogene]

Ce ne sont que des warnings informatifs indiquant qu'une opération demandée peut ne pas faire ce que pense le programmeur.

Par contre, le comportement est bien défini : la conversion entier signé -> entier non signé donne un résultat parfaitement prévisible.

Code :

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

1
2
3
4
5
6
7
 
  unsigned int test1 = -2;
  int test2 =-2;
...
if( test1 == test2 ){
    printf("equal\n");
  }

Voila un test qui ne teste pas grand chose : dans une telle expression, test1 et test2 subissent avant évaluation les conversions standard : l'opérande de type int (test2) est transformée en une valeur de type unsigned int (type de test1). Il n'est donc pas étonnant d'avoir pour résultat "vrai".

Par contre la situation diffère ici :

Code :

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

1
2
3
4
5
6
7
 
  unsigned char test1 = -2;
  int test2 =-2;
...
if( test1 == test2 ){
    printf("equal\n");
  }

Ici la comparaison répondra "Faux", car cette fois, c'est test1 qui sera converti en le type de test2 (int) avant comparaison (pourvu que les valeurs d'un unsigned char puissent être représentées dans un int, sinon, on aura conversion en unsigned int des deux opérandes).

On voit que la comparaison signed/unsigned est un peu délicate ce qui justifie l'émission d'un avertissement.

[Lavock]

En faite, les choses on été faite pour que les opération ne diffère pas, pour une grande partie.

Je crois que les opération qui diffère sont >,<,>=,<=,*,\. Pour le reste, c'est tout pareil.

A savoir que (unsigned char) -1 == 255. C'est une histoire de complément !

Un entier signé, c'est 1 bit de signe, et les autres de valeurs. Mais si on code les valeurs comme pour les positif, on à deux 0 oO ! Du coup, on procède différemment :

Donc pour trouver un nombre négatif, on hôte 1 est on inverse tous les bits :
1 = 00000001 -> 00000000 -> 111111111 = -1 (ou 255).

En gros, dans le deuxième cas, on compare :
0xFFFE == 0x[00]FE.

[diogene]

La méthode de représentation que tu évoques (code complément à 2) n'est pas la seule permise en C pour les entiers signés. Il y en a deux autres possibles (signe+valeur absolue et complément à 1)

C'est pourquoi, les conversions entre entiers signés et non signés ne sont pas basées sur la représentation binaire des nombres.

Si (unsigned char) -1 == 255 c'est parce que (dans ton cas) UCHAR_MAX est 255. La conversion de -1 en unsigned char donnera UCHAR_MAX+1-1 = UCHAR_MAX

Dans le deuxième cas, test1 est égal à UCHAR_MAX-1. Il est converti en int en conservant cette valeur qui est différente de celle de test2 (-2)

Dans le premier cas, test1 vaut UINT_MAX-1 et test2 est converti en unsigned int et vaut UINT_MAX+1-2 = UINT_MAX-1 donc la même valeur.

[Rozebud]

Pour les warnings, essaie -Wall dans ton compilateur, ou bien peut-être as tu mis -w.

Sinon, même si ca marche, à éviter

[Lavock]

La méthode de représentation que tu évoques (code complément à 2) n'est pas la seule permise en C pour les entiers signés. Il y en a deux autres possibles (signe+valeur absolue et complément à 1)

Ca dépend surtout de la machine... et je suis trop jeune pour avoir connu des machines qui n'utilisaient pas le complément à 2 pour les entiers signés !

[Biosox]

toutes ces précisions sont utiles, merci!

j'utilise cmake et gcc, et j'ai les flags "-Werror -Wall"... c'est pourquoi je suis surpris...
clairement, les options utilisées ne sont pas celle que je crois etre utilisées...
vais devoir relire ma doc cmake

[Jean-Marc.Bourguet]

Tous les warnings ne sont pas compris dans -Wall (qui porte mal son nom, ce devrait plutôt être -Wrecommanded ou -Wcommon). -Wsign-conversion est nécessaire pour ce que tu veux. (Il y a aussi un -Wextra -- -W tout seul dans les anciennes versions -- qui est un ensemble supplémentaire de warnings courant).

[Arnaud F.]

Tous les warnings ne sont pas compris dans -Wall (qui porte mal son nom, ce devrait plutôt être -Wrecommanded ou -Wcommon). -Wsign-conversion est nécessaire pour ce que tu veux. (Il y a aussi un -Wextra -- -W tout seul dans les anciennes versions -- qui est un ensemble supplémentaire de warnings courant).

Pour confirmer ces dires :

Code :

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

1
2
3
4
5
$ gcc test.c -W
test.c: In function ‘main’:
test.c:14: warning: comparison between signed and unsigned integer expressions
test.c:18: warning: comparison between signed and unsigned integer expressions
test.c:22: warning: comparison between signed and unsigned integer expressions

Code :

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

1
2
$ gcc test.c -Wall
$