Comment supprimer l’avertissement “la conversion de ‘int’ de ‘int’ peut altérer sa valeur”

Je pensais que si je cast un nombre comme celui-ci (unsigned char)32 cela suffirait pour résoudre l’avertissement du compilateur, mais ce n’était pas comme si j’avais planifié.

Ici, j’ai la partie suivante du programme qui explique réellement le problème:

 #include  #include  #include  int main(void){ char *ptr = malloc(6); const char *name = "MICHI"; unsigned int i = 0; if(ptr){ strcpy(ptr, name); ptr[strlen(ptr)] = '\0'; }else{ return 1; } while(ptr[i] != '\0'){ if((ptr[i] >= 'A') && (ptr[i] <= 'Z')){ ptr[i] += (unsigned char)32; } i++; } printf("Name = %s\n",ptr); if(ptr){ free(ptr); ptr = NULL; } } 

Quand j’essaye de le comstackr avec les avertissements du compilateur ON, j’obtiens ceci:

 error: conversion to 'char' from 'int' may alter its value [-Werror=conversion]| 

Cela signifie que le ptr[i] += (unsigned char)32; suivant ptr[i] += (unsigned char)32; ne fournit pas une solution à mon problème.

Ma question est la suivante: comment supprimer cet avertissement, car je n’en ai aucune idée?

Ideone n’aide pas beaucoup, car je pense que tous les avertissements sont désactivés.

OP utilise un niveau d’alerte très difficile

warning: la conversion de ‘int’ en ‘char’ peut altérer sa valeur [-Wconversion]

  // Both cause the warning ptr[i] += (unsigned char) 32; ptr[i] = tolower(ptr[i]); 

Pour répondre à l’avertissement, soyez explicite

  ptr[i] = (char) (ptr[i] + 32); ptr[i] = (char) tolower(ptr[i]); 

[Détails] Les opérations impliquant des types étroits tels que char, short, unsigned char, _Bool, ... feront que cet opérande soit promu, en utilisant les promotions d’entier habituelles en int/unsigned , comme ptr[i] . Donc, réassigner int/unsigned à un caractère déclenche l’avertissement. Une dissortingbution explicite du résultat apaise l’avertissement.

De nombreuses compilations omettent l’ [-Wconversion] or equivalent et ne verront donc pas l’avertissement.

En ajoutant aux commentaires, il existe en fait un moyen de faire taire l’avertissement en utilisant uniquement les conversions:

 ptr[i] = (char)((int)ptr[i] + 32); 

Ainsi, la transaction avec la conversion est déléguée à l’opérateur d’affectation qui est (comme indiqué par @Olaf) défini dans la norme 6.5.16.1p3 .

Cette ligne:

 ptr[i] += (unsigned char)32; 

signifie vraiment:

 ptr[i] = ptr[i] + 32; 

Maintenant … ptr[i] peut légalement être aussi grand que 255. Et si vous ajoutez 255 + 32, vous obtiendrez 287.

Comment proposez-vous l’ajustement de la valeur 287 dans un caractère ayant une valeur maximale de 255?
Vous ne pouvez pas faire ça. C’est ce que l’erreur est à propos.

Si vous voulez vous débarrasser de l’erreur, vous devez d’abord savoir exactement ce que vous voulez exactement quand un ajout risque de créer des valeurs plus grandes qu’un caractère ne peut contenir.

Si vous essayez simplement de convertir les lettres AZ en leurs équivalents minuscules, utilisez simplement l’API approprié pour cela: tolower


Si vous n’utilisez vraiment pas tolower , essayez ceci:

 ptr[i] = (unsigned char)(ptr[i] + 32); 

La différence importante est que la conversion de type est sur le résultat du calcul et non sur l’un des opérandes de l’opération.

L’avertissement vient du fait qu’il est possible que vous dépassiez la limite d’une valeur de caractère.

En général, éviter l’avertissement n’est pas une bonne idée.

Utilisez tolower() pour que le travail soit effectué de manière plus propre.