Discussion :

[_concept_]

Bonjour,
tout est dans le titre.
J'aimerais avoir quelques précision sur la promotion intégrale :
-surtout : quand s'applique - t elle précisement ?
Si une fonction attend un char par exemple puis - je lui passer directement un int en sachant qu'elle serra convertie par la suite (ou pas...).
Ou alors cette régles ne s'applique - t - elle que sur les opérandes d'une opération lors d'une affectation ?
Merci de vos réponses

[diogene]

J'aimerais avoir quelques précision sur la promotion intégrale :
-surtout : quand s'applique - t elle précisement ?

Elle s'applique
- à l'opérande des opérateurs unaires + , - et ~
- aux arguments des fonctions lorsque le type du paramètre n'est pas connu (comme par exemple les arguments d'un printf)
- dans les expressions composées de deux opérandes arithmétiques :
Opérations arithmétiques (+,-,*,/,%), comparaisons (==, !=,>,...), opérations bit à bit (&, |, ^), opérateurs de décalage (<< , >>), opérateur ?: (pour les deux derniers opérandes),

Si une fonction attend un char par exemple puis - je lui passer directement un int en sachant qu'elle serra convertie par la suite (ou pas...).

Il ne s'agit pas ici de promotion des "petits entiers" : Il y a conversion de l'int en char pour pouvoir assigner la valeur à un char, comme dans l'opération d'affectation "char" = "int"

Ou alors cette régles ne s'applique - t - elle que sur les opérandes d'une opération lors d'une affectation ?

Elle ne s'applique pas lors de l'assignation : Si je veux assigner une valeur de type Tv à un objet de type To par une assignation (=), il faut que la conversion de Tv en To soit faite. Il n'y a pas de promotion dans cette affaire. Par contre, évidemment, lors de l'évaluation de la valeur, il y a peut être eu des promotions.
Par exemple

Code :

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

1
2
3
 char a  = 1;
 short b = -2;
 unsigned char c= a+b;

donne symboliquement les opérations suivantes :

- a et b sont promus en int tous deux (l'ordre est indéterminé).
a : char(1) -> int(1)
b : short(-2) -> int(-2)

- L'opération + entre les deux int a lieu et donne comme résultat un int
a+b : int(1)+int(-2) -> int(-1)

- L'assignation a lieu après conversion du second membre en le type du premier :
c = a+b : c=(unsigned char) int(-1) -> c = unsigned char (255) (pour un char sur 8 bits)

L'expression est de type unsigned char et vaut 255 et son évaluation a un effet de bord sur c : c <- 255

[_concept_]

Merci pour cette réponse précise.
A propos de cette "règle", je pensais nottamment au fonction de ctype. Faut-il leur passer un int ou un unsigned char ?

- a et b sont promus en int tous deux (l'ordre est indéterminé).
a : char(1) -> int(1)
b : short(-2) -> int(-2)

- L'opération + entre les deux int a lieu et donne comme résultat un int
a+b : int(1)+int(-2) -> int(-1)

- L'assignation a lieu après conversion du second membre en le type du premier :
c = a+b : c=(unsigned char) int(-1) -> c = unsigned char (255) (pour un char sur 8 bits)

L'expression est de type unsigned char et vaut 255 et son évaluation a un effet de bord sur c : c <- 255

Hum je ne saisis pas tout la par contre...
Dans les deux premiers cas il a conversion implicite des char en int.
Et dans le dernier cas l'une des opérandes étant de type int, il devrait y avoir un cast implicite vers le type le plus précis donc 'c' devrait être de type int non ?

A vrai dire j'ai du mal à saisir le résultat de ce code egalement :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int main(void)
{
	 char a = 1;
     short b = -2;
     unsigned char c = a + b;
 
     printf("%d %d -> %d",
            sizeof a, sizeof b, sizeof c);
 
	 return 0;
}

[diogene]

Et dans le dernier cas l'une des opérandes étant de type int, il devrait y avoir un cast implicite vers le type le plus précis donc 'c' devrait être de type int non ?

On ne peut pas changer le type d'un objet, tout ce qu'on peut faire, c'est changer le type de la valeur pour l'adapter au type de l'objet. Le type de l'objet est déterminé à sa création et ne peut changer. Il y a d'excellentes raisons à cela, la plus importante est que le type de l'objet détermine la taille mémoire qui lui a été attribuée. Par exemple, un unsigned char a besoin d'un byte et un int fait au minimum deux bytes. Comment mettre les deux bytes dans un byte ? La solution est de convertir le int en unsigned char et mettre le byte obtenu dans c.

A vrai dire j'ai du mal à saisir le résultat de ce code egalement :

Probablement, tu obtiens 1 2 -> 1
sizeof (char) ou sizeof (unsigned char) ou sizeof (signed char) vaut toujours 1, et il est probable que sizeof(short) vaut 2
Par contre avec

Code :

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

1
2
     printf("%d %d -> %d %d ",
            sizeof a, sizeof b, sizeof c ,sizeof (a+b));

tu obtiendras sans doute 1 2 -> 1 4 (si tes int font 4 bytes)

A propos de cette "règle", je pensais nottamment au fonction de ctype. Faut-il leur passer un int ou un unsigned char ?

Les fonctions de <ctype.h> ont un argument int et renvoie int. Donc, indépendamment même des questions de promotions, si tu places un argument char, il sera converti en int. Si l'argument est une constante littérale, par exemple 'A', alors la question ne se pose même pas puisqu'une telle constante est déjà du type int.

[_concept_]

On ne peut pas changer le type d'un objet, tout ce qu'on peut faire, c'est changer le type de la valeur pour l'adapter au type de l'objet. Le type de l'objet est déterminé à sa création et ne peut changer.

Logique...

Probablement, tu obtiens 1 2 -> 1

Oui, oui merci les explications ci dessus m'ont eclairées.

Les fonctions de <ctype.h> ont un argument int et renvoie int. Donc, indépendamment même des questions de promotions, si tu places un argument char, il sera converti en int. Si l'argument est une constante littérale, par exemple 'A', alors la question ne se pose même pas puisqu'une telle constante est déjà du type int.

Hum si je me refère au man je lis ça :

These functions check whether c, which must have the value of an unsigned char or EOF, falls into a certain character class according to the current locale.

[diogene]

These functions check whether c, which must have the value of an unsigned char or EOF, falls into a certain character class according to the current locale.

C'est bizarre ce libellé parce que
- EOF est du type int
- les constantes caractères comme 'A' sont du type int.

La norme est claire : le prototype de ces fonctions est :
int fonction(int)

[_concept_]

Donc un cast en unsigned char sur l'argument serait inutile ?

[diogene]

oui

[_concept_]

ok merci pour tout

[Médinoc]

Le cast en unsigned char n'est pas du tout inutile quand le caractère testé n'est pas une constante caractère: S'il s'agit d'un caractère d'une chaîne (donc, un bète char), tout caractère non-ASCII (supérieur à 127) entraine un comportement indéfini s'il n'est pas casté en unsigned char avant sa promotion en int.

[diogene]

...(donc, un bète char), tout caractère non-ASCII (supérieur à 127) entraine un comportement indéfini s'il n'est pas casté en unsigned char avant sa promotion en int.

La promotion d'un char en int ne donne pas un comportement indéfini même si il donne des résultats différents selon que le char est un signed char ou un unsigned char.

En l'occurence, il était question de caster l'argument des fonctions de <ctype.h> et je ne crois pas que cela soit nécessaire.

[Médinoc]

These functions check whether c, which must have the value of an unsigned char or EOF, falls into a certain character class according to the current locale.

Ou en d'autres termes: La seule valeur non-comprise entre 0 et 255 qu'on a le droit de passer aux fonctions de <ctype.h>, c'est EOF. Toute autre valeur négative, ou supérieure à 255, entraine un comportement indéfini.

Prenons un exemple concret: 'é', dont le code est 233 en Latin-1, Unicode et Windows-1252.
Une fois saisi avec fgets(), on le caractère 'é' dans un tableau de char, qu'on va appeler str. Seulement, les char étant signés par défaut, str[0] ('é') ne vaut pas 233, mais -23.

• isalpha(str[0]) : char signé promu en int --> résultat=-23 : Ce n'est ni entre 0 et 255, ni EOF --> Comportement indéfini.
• isalpha((unsigned char)str[0]) : char signé converti en non-signé, char non-signé promu en int --> résultat=233 : Valeur entre 0 et 255 --> OK.

[diogene]

@ Médinoc :
OK !

[gl]

Seulement, les char étant signés par défaut, str[0] ('é') ne vaut pas 233, mais -23.

Juste une petite précision, les char ne sont pas forcément signé par défaut, c'est dépendant de l'implémentation, je cite :

The implementation shall define char to have the same range, representation, and behavior as either signed char or unsigned char.

[Médinoc]

Par contre, il me semble que les wchar_t sont toujours non-signés, non?

[gl]

Par contre, il me semble que les wchar_t sont toujours non-signés, non?

Dans le doute, j'ai été jeté un coup d'œil et il semble que non :

If wchar_t (see 7.17) is defined as a signed integer type, the value of WCHAR_MIN shall be no greater than −127 and the value of WCHAR_MAX shall be no less than 127; otherwise, wchar_t is defined as an unsigned integer type, and the value of WCHAR_MIN shall be 0 and the value of WCHAR_MAX shall be no less than 255.