Discussion :

[mrTerribleLie]

Bonjour, j'ai récemment recommencé à programmer en C et j'ai créé un petit programme bien simple qui convertit des valeurs décimales en nombres binaires. La fonction qui s'occupe de la conversion retourne une valeur de type unsigned long int. Étant donné le type retourné, mon programme ne convertis que les nombres inférieurs à 1023, (puisque la valeur maximale d'une variable de type unsigned long int est 4 294 967 295). Mais voilà, mon programme teste la valeur de son argument pour vérifier que celui-ci est bien inférieur à 1023, et si ce n'est pas le cas, il retourne -1. Pourtant, ma fonction est sensée retourner une valeur non-signée et mon compilateur ne me retourne aucune erreur ou avertissement. Le programme fonctionne très bien, mais je ne comprends pas pourquoi mon compilateur ne me retourne pas d'erreur ou d'avertissement... y'aurait-il une conversion implicite?

[Lucien63]

y'aurait-il une conversion implicite?

Oui.
Pourquoi il n'y a pas de warning ? Peut-être le compilateur est mal configuré !
Sans code, je ne peux t'en dire plus.

[mrTerribleLie]

Oui.
Pourquoi il n'y a pas de warning ? Peut-être le compilateur est mal configuré !
Sans code, je ne peux t'en dire plus.

Mon edi (Code:Blocks 10.05) utilise la configuration par défaut (avec MinGW utilisant GCC 4.5.2). Chose étonnante, normalement il me retourne un avertissement quand il y a conversion implicite.

Pour ce qui est du code :

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
28
29
unsigned long int dec_to_binary(unsigned int iDecimal_value) {
 
	unsigned long int iResult = 0;
 
	int iBinary_value[10] = {0};
	int i = 0;
 
    /* Étape 1 : on vérifie que le nombre n'est pas supérieur à 1022, sans quoi la valeur binaire dépasse la taille maximale
     * d'un entier non-signé de type long (4 294 967 295).
     */
	if(iDecimal_value > 1022) {
	    return -1;
	}
 
 
	/* Étape 2 : on effectue une conversion des bases grâce à l'opération de modulo, puis le nombre est divisé par 2. */
	while(iDecimal_value != 0) {
		iBinary_value[i] = iDecimal_value % 2;
		iDecimal_value /= 2;
		i++;
	}
 
	/* Étape 3 : on construit le nombre binaire en se servant de puissances de 10 */
	for(i = 0; i<10; i++) {
		iResult += iBinary_value[i] * pow(10,i);
	}
 
	return iResult;
}

Edit: J'ai même essayé en lignes de commande avec le flag -Wall.
Edit 2: Avec -Wconversion, il me retourne un warning.

[droggo]

Lai,

Je ne vois pas l'intérêt de ta fonction, mais je vois à qui tu veux l'utiliser : l'affichage en binaire.

Si c'est bien le cas, tu fais fausse route : ton procédé te limite, en empêchant de gérer n'importe quelle valeur valide de ton paramètre iDecimal_value.
La bonne démarche est alors de créer directement la chaîne de caractères représentant ta donnée, habituellement en fixant le nombre de caractères qui sera utilisé.

[mrTerribleLie]

Lai,

Je ne vois pas l'intérêt de ta fonction, mais je vois à qui tu veux l'utiliser : l'affichage en binaire.

Si c'est bien le cas, tu fais fausse route : ton procédé te limite, en empêchant de gérer n'importe quelle valeur valide de ton paramètre iDecimal_value.
La bonne démarche est alors de créer directement la chaîne de caractères représentant ta donnée, habituellement en fixant le nombre de caractères qui sera utilisé.

Merci, c'est bien noté, mais le but ici n'était que de me rafraîchir la mémoire quant aux notions de C que j'avais appris il y a quelques années, je me replonge dans les chaînes de caractère et je vais sûrement faire une nouvelle version de ce programme. D'ailleurs, c'est bien loin tout ça

[diogene]

La règle de conversion d'un type entier vers un type entier non signé est parfaitement définie par la norme du C dans tous les cas :
Le résultat est égal à la valeur de l'entier ramenée dans la plage de valeurs de l'entier non signé par ajout ou soustraction d'un nombre de fois suffisant de la valeur maximum de l'entier non signé +1.

J'explicite sur un exemple : Soit à convertir un int vers un unsigned char de valeur maximum 255.
- soit un int valant 25762
Comme 25762 = 100*256+162, l'unsigned char vaudra 162 (= 25762-100*256 donc par 100 soustractions de 256).
- soit un int valant -25762
Comme -25762 = -101*256+94, l'unsigned char vaudra 94 (= -25762+101*256 donc par 101 additions de 256).

Code :

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

1
2
3
4
int i = 25762;
unsigned char uci = i; // uci==162
int j = -25762;
unsigned char ucj = j; // ucj==94

Le return -1 dans ton code retourne donc en fait 4 294 967 295

La conversion d'un entier vers un entier signé est plus problématique : si la valeur du nombre peut être représentée dans la plage de valeur de l'entier signé, alors la conversion conserve la valeur. Sinon le résultat dépend de l'implémentation (et n'est donc pas portable)

Code :

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

1
2
3
4
unsigned int ui = 122;
signed char scui = ui ;  // scui==122
unsigned int uj = 254;
signed char scuj = uj ;  // scuj==??? dépend de l'implémentation pour un signed char <=127

Tu peux donc avoir des problèmes si ton code se poursuit par quelque chose du genre :

Code :

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

1
2
3
4
long int i = dec_to_binary(....)
// ou 
if(dec_to_binary(....)==-1)...
// et le compilateur devrait émettre un warning pour la comparaison signé/non signé

dont le résultat est dépendant de l'implémentation.