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.