Chapitre 3: TYPES DE BASE, OPÉRATEURS ET EXPRESSIONS

Récapitulation du vocabulaire





Les variables et les constante sont les données principales qui peuvent être manipulées par un programme. Les déclarations introduisent les variables qui sont utilisées, fixent leur type et parfois aussi leur valeur de départ. Les opérateurs contrôlent les actions que subissent les valeurs des données. Pour produire de nouvelles valeurs, les
variables et les constantes peuvent être combinées à l'aide des opérateurs dans des expressions. Le type d'une donnée détermine l'ensemble des valeurs admissibles, le nombre d'octets à réserver en mémoire et l'ensemble des
opérateurs qui peuvent y être appliqués.


Motivation


La grande flexibilité de C nous permet d'utiliser des opérandes de différents types dans un même calcul. Cet avantage peut se transformer dans un terrible piège si nous ne prévoyons pas correctement les effets secondaires d'une telle opération (conversions de type automatiques, arrondissements, etc.). Une étude minutieuse
de ce chapitre peut donc aider à éviter des phénomènes parfois 'inexplicables' ...


3.1. Les types simples

Ensembles de nombres et leur représentation

En mathématiques, nous distinguons divers ensembles de nombres:

* l'ensemble des entiers naturels IN,

* l'ensemble des entiers relatifs ZZ,

* l'ensemble des rationnels Q,

* l'ensemble des réels IR.

En mathématiques l'ordre de grandeur des nombres est illimité et les rationnels peuvent être exprimés sans perte de précision.


Un ordinateur ne peut traiter aisément que des nombres entiers d'une taille limitée. Il utilise le système binaire pour calculer et sauvegarder ces nombres. Ce n'est que par des astuces de calcul et de représentation que l'ordinateur obtient des valeurs correctement approchées des entiers très
grands, des réels ou des rationnels à partie décimale infinie.

Les charges du programmeur

Même un programmeur utilisant C ne
doit pas connaître tous les détails des méthodes de codage et de calcul, il
doit quand même être capable de:

- choisir un type
numérique approprié à un problème donné;
c.-à-d.: trouver un optimum de précision, de temps de calcul et d'espace à
réserver en mémoire



- choisir un type
approprié pour la représentation sur l'écran



- prévoir le type
résultant d'une opération entre différents types numériques;
c.-à-d.: connaître les transformations automatiques de type que C accomplit
lors des calculs (voir 3.7.1).



- prévoir et optimiser la
précision des résultats intermédiaires au cours d'un calcul complexe;
c.-à-d.: changer si nécessaire l'ordre des opérations ou forcer
l'ordinateur à utiliser un type numérique mieux adapté (casting: voir 3.7.2).



Exemple

Supposons
que la mantisse du type choisi ne comprenne que 6 positions décimales (ce qui
est très réaliste pour le type float):

3.1.1. Les types entiers







Avant de pouvoir
utiliser une variable, nous devons nous intéresser à deux caractéristiques de
son type numérique:


(1) le domaine des valeurs admissibles

(2) le nombre d'octets qui est réservé pour une variable

Le tableau suivant résume les caractéristiques des types numériques entiers
de C :




- char : caractère

Une variable du type char
peut contenir une valeur entre -128 et 127 et ellepeut subir les mêmes
opérations que les variables du type short, int ou long.



- int : entier standard


Sur
chaque machine, le type int est le type de base pour les calculs avec
les entiers. Le codage des variables du type int est donc dépendant de
la machine. Sur les IBM-PC sous MS-DOS, une variable du type int est
codée dans deux octets.



- short : entier court


Le type short
est en général codé dans 2 octets. Comme une variable int occupe aussi 2
octets sur notre système, le type short devient seulement nécessaire, si
on veut utiliser le même programme sur d'autres machines, sur lesquelles le
type standard des entiers n'est pas forcément 2 octets.

- Les modificateurs signed/unsigned:

Si on ajoute le préfixe unsigned à la définition d'un type de
variables entières, les domaines des variables sont déplacés comme suit:






Remarques

1. Le calcul avec des entiers
définis comme unsigned correspond à l'arithmétique modulo 2ⁿ.
Ainsi, en utilisant une variable Xdu type unsigned short,
nous obtenons le résultat suivant:

	Affectation :	X = 65500 + 100
	Résultat :	X = 64	/* [+216] */

2. Par défaut, les types entiers short,
int, long sont munis d'un signe. Le type par défaut de char
est dépendant du compilateur et peut être signed ou unsigned.
Ainsi, l'attribut signed a seulement un sens en liaison avec char et
peut forcer la machine à utiliser la représentation des caractères avec signe
(qui n'est cependant pas très usuelle).

3. Les valeurs limites des
differents types sont indiquées dans le fichier header <limits.h>.

4. En principe, on peut dire que

sizeof(short) <= sizeof(int) <= sizeof(long)


Ainsi sur certaine architecture on peut avoir

short = 2 octets, int = 2 octets, long = 4 octets


et sur d'autre

short = 2 octets, int = 4 octets, long = 4 octets ( Il sera intéressant de voir l'implementation dans un
environnement 64 bits! )

3.1.2. Les types rationnels



En informatique, les rationnels
sont souvent appelés des 'flottants'. Ce terme vient de 'en virgule
flottante' et trouve sa racine dans la notation traditionnelle des
rationnels:




Exemples

3.14159*100 1.25003*10-12 4.3001*

















10321 -1.5*103

En C, nous avons le choix entre trois types de rationnels: float, double
et long double. Dans le tableau ci-dessous, vous trouverez leurs
caractéristiques:

	min et max	représentent les valeurs minimales et maximales
		positives. Les valeurs négatives peuvent varier dans
		les mêmes domaines.
	mantisse	indique le nombre de chiffres significatifs de la
		mantisse.

Remarque avancée

Les détails de l'implémentation sont indiqués dans le fichier header <float.h>.

Exercice 3.1









Quel(s) type(s) numérique(s) pouvez-vous utiliser pour les groupes de
nombres suivants? Dressez un tableau et marquez le choix le plus économique:

(1) 1 12 4 0 -125 (2) 1 12 -4 0 250 (3) 1 12 4 0 250 (4) 1 12 -4 0.5 125 (5) -220

















32000 0 (6) -3000005.000000001 (7) 410 50000 2 (8) 410 50000 -2 (9) 3.14159265 1015 (10) 2*10⁷ 10000001 (11) 2*10^-7 10000001 (12) -1.05*1050 0.0001 (13) 305.122212 0 -12

3.2. La déclaration des variables simples



Maintenant que nous connaissons les principaux types de variables, il nous
faut encore la syntaxe pour leur déclaration:

Déclaration de variables en langage algorithmique

<Type> <NomVar1>,<NomVar2>,...,<NomVarN>

Déclaration de variables en C

<Type> <NomVar1>,<NomVar2>,...,<NomVarN>;

Prenons quelques déclarations du langage descriptif,

entier COMPTEUR,X,Yréel HAUTEUR,LARGEUR,MASSE_ATOMIQUEcaractère TOUCHEbooléen T_PRESSEE

et traduisons-les en des déclarations du langage C :

int compteur,X,Y;float hauteur,largeur;double masse_atomique;char touche;int t_pressee;

Langage algorithmique --> C

En général. nous avons le choix entre plusieurs types et nous devons trouver
celui qui correspond le mieux au domaine et aux valeurs à traiter. Voici
quelques règles générales qui concernent la traduction des déclarations de
variables numériques du langage algorithmique en C :

- La syntaxe des déclarations en C ressemble à celle du
langage algorithmique. Remarquez quand même les points-virgules à la fin des
déclarations en C.

entier : Nous avons le choix entre tous les types entiers
(inclusivement char) dans leurs formes signed ou unsigned.
Si les nombres deviennent trop grands pour unsigned long, il faut
utiliser un type rationnel (p.ex: double)

réel : Nous pouvons choisir entre les trois types rationnels
en observant non seulement la grandeur maximale de l'exposant, mais plus encore
le nombre de chiffres significatifs de la mantisse.

caractère : Toute variable du type char peut contenir
un (seul) caractère. En C, il faut toujours être conscient que ce 'caractère'
n'est autre chose qu'un nombre correspondant à un code (ici: code ASCII). Ce
nombre peut être intégré dans toute sorte d'opérations algébriques ou logiques
...

chaîne : En C il n'existe pas de type spécial pour chaînes de
caractères. Les moyens de traiter les chaînes de caractères seront décrits au
chapitre 8.

booléen : En C il n'existe pas de type spécial pour variables
booléennes. Tous les types de variables numériques peuvent être utilisés pour
exprimer des opérations logiques:

valeur logique faux	<=>	valeur numérique zéro
valeur logique vrai	<=>	toute valeur différente de zéro

Si
l'utilisation d'une variable booléenne est indispensable, le plus naturel sera
d'utiliser une variable du type int.

Les opérations logiques en C retournent toujours des résultats du type int:

0 pour faux
1 pour vrai

Exercice 3.2









Traduisez les déclarations suivantes en C, sachant que vous travaillerez
dans les ensembles de nombres indiqués. Choisissez les types les plus
économiques, sans perdre en précision.

3.2.1. Les constantes numériques






En pratique, nous utilisons souvent des valeurs constantes pour calculer,
pour initialiser des variables, pour les comparer aux variables, etc. Dans ces
cas, l'ordinateur doit attribuer un type numérique aux valeurs constantes. Pour
pouvoir prévoir le résultat et le type exact des calculs, il est important pour
le programmeur de connaître les règles selon lesquelles l'ordinateur choisit
les types pour les constantes.

- Les constantes entières



Type automatique

Lors de l'attribution d'un type à une constante entière, C choisit en
général la solution la plus économique:

Le type des constantes entières * Si possible, les constantes
entières obtiennent le type int.

* Si le nombre est trop grand pour int (p.ex: -40000 ou +40000) il
aura automatiquement le type long.

* Si le nombre est trop grand pour long, il aura le type unsigned
long.

* Si le nombre est trop grand pour unsigned long, la réaction du
programme est imprévisible.

Type forcé

Si nous voulons forcer l'ordinateur à utiliser un type de notre choix, nous
pouvons employer les suffixes suivants:

Exemples


Base octale et hexadécimale

Il est possible de déclarer des constantes entières en utilisant la base octale
ou hexadécimale:

* Si une constante entière commence par 0 (zéro), alors elle est
interprétée en base octale.

* Si une constante entière commence par 0x ou 0X , alors elle
est interprétée en base hexadécimale.

Exemples

- Les constantes rationnelles



Les constantes rationnelles peuvent être indiquées:

* en notation décimale, c.-à-d. à l'aide d'un point décimal:

Exemples

123.4 -0.001 1.0

* en notation exponentielle, c.-à-d. à l'aide d'un exposant séparé du
nombre décimal par les caractères 'e' ou 'E':

Exemples

1234e-1 -1E-3 0.01E2

L'ordinateur reconnaît les constantes rationnelles au point décimal ou au
séparateur de l'exposant ('e' ou 'E'). Par défaut, les constantes rationnelles
sont du type double.

Le type des constantes rationnelles * Sans suffixe, les
constantes rationnelles sont du type double.

* Le suffixe f ou F force l'utilisation du type float.

* Le suffixe l ou L force l'utilisation du type long double.


- Les caractères constants



Les constantes qui désignent un (seul) caractère sont toujours indiquées
entre des apostrophes: par exemple 'x'. La valeur d'un caractère
constant est le code interne de ce caractère. Ce code (ici: le code ASCII) est
dépendant de la machine.

Exercice 3.3









Complétez le tableau suivant:

base décimale	base octale	base hexadécimale	représ. binaire
	01770
8100
		0XAAAA
			1001001001
			1100101011111110
10000
	0234

Exercice 3.4









Pour les constantes correctement définies, trouvez les types et les
valeurs numériques décimales:

	12332	23.4	345LU	34.5L	-1.0
	0xeba	0123l	'\n'	1.23ul	-1.0e-1
	0FE0	40000	40000u	70000u	1e1f
	'0'	o	'\0'	0	'O'
	67e0	\r	01001	0.0l	0XEUL

3.2.2. Initialisation des
variables



Initialisation

En C, il est possible d'initialiser les variables lors de leur déclaration:

int MAX = 1023; char TAB = '\t'; float X = 1.05e-4;

const

En utilisant l'attribut const, nous pouvons indiquer que la valeur
d'une variable ne change pas au cours d'un programme:

const int MAX = 767; const double e = 2.71828182845905; const char NEWLINE = '\n';

3.3. Les opérateurs standard



Affectation en langage algorithmique

en <NomVariable> ranger <Expression>

Affectation en C

<NomVariable> = <Expression>;

Exemples d'affectations

Reprenons les exemples du cours d'algorithmique pour illustrer différents
types d'affectations:

- L'affectation avec des valeurs constantes

Langage algorithmique	C	Type de la constante
en LONG ranger 141	LONG = 141;	(const. entière)
en PI ranger 3.1415926	PI = 3.1415926;	(const. réelle)
en NATION ranger "L"	NATION = 'L';	(caractère const.)

- L'affectation avec des valeurs de variables

Langage algorithmique	C
en VALEUR ranger X1A	VALEUR = X1A;
en LETTRE ranger COURRIER	LETTRE = COURRIER;

- L'affectation avec des valeurs d'expressions

Langage algorithmique	C
en AIRE ranger PI*R2	AIRE = PI*pow(R,2);
en MOYENNE ranger (A+B)/2	MOYENNE = (A+B)/2;
en UN ranger sin2(X)+cos2(X)	UN=pow(sin(X),2)+pow(cos(X),2);
en RES ranger 45+5*X	RES = 45+5*X;
en PLUSGRAND ranger (X>Y)	PLUSGRAND = (X>Y);
en CORRECT ranger ('a'='a')	CORRECT = ('a' == 'a');

Observations

Les opérateurs et les fonctions arithmétiques utilisées dans les expressions
seront introduites dans la suite du chapitre. Observons déjà que:

* il n'existe pas de fonction standard en C pour calculer le carré d'une
valeur; on peut se référer à la fonction plus générale pow(x,y) qui
calcule x^y (voir 3.5.).

* le test d'égalité en C se formule avec deux signes d'égalité ==
, l'affectation avec un seul = .

3.3.1. Les opérateurs connus



Avant de nous lancer dans les 'spécialités' du langage C, retrouvons d'abord
les opérateurs correspondant à ceux que nous connaissons déjà en langage
descriptif et en Pascal.

Opérateurs arithmétiques

Opérateurs logiques


Opérateurs de comparaison


Opérations logiques

Les résultats des opérations de comparaison et des opérateurs logiques sont
du type int:

- la valeur 1 correspond à la valeur booléenne vrai

- la valeur 0 correspond à la valeur booléenne faux

Les opérateurs logiques considèrent toute valeur différente de zéro comme vrai
et zéro comme faux:

	32 && 2.3		1
	!65.34		0
	0||!(32 > 12)		0

3.3.2. Les opérateurs particuliers
de C



- Les opérateurs d'affectation



Opérateurs d'affectation

En pratique, nous retrouvons souvent des affectations comme:

i = i + 2

En C, nous utiliserons plutôt la formulation plus compacte:

i += 2

L'opérateur += est
un opérateur d'affectation.

Pour la plupart des expressions de la forme:

expr1 = (expr1) op (expr2)

il existe une formulation équivalente qui utilise un opérateur
d'affectation:

expr1 op= expr2

Opérateurs d'affectation


Avantages

La formulation avec un opérateur d'affectation est souvent plus près de la
logique humaine:

Un homme dirait <<Ajoute 2 à I>>

plutôt que <<Ajoute 2 à I et écris le résultat dans I>>

Les opérateurs d'affectation peuvent aider le compilateur à générer un code
plus efficient parce que expr1 n'est évalué qu'une seule fois.

Les opérateurs d'affectation deviennent le plus intéressant si expr1
est une expression complexe. Ceci peut être le cas si nous calculons avec des
tableaux. L'expression:

Element[n*i+j] = Element[n*i+j] * x[j]

peut être formulée de manière plus efficiente et plus claire:

Element[n*i+j] *= x[j]

- Opérateurs d'incrémentation et de décrémentation



Les affectations les plus fréquentes sont du type:

I = I + 1 et I = I - 1

En C, nous disposons de deux opérateurs inhabituels pour ces affectations:

Les opérateurs ++ et -- sont employés dans les cas suivants:

incrémenter/décrémenter une variable (p.ex: dans une boucle). Dans ce cas il
n'y a pas de différence entre la notation préfixe (++I --I) et la notation postfixe (I++ I--).

incrémenter/décrémenter une variable et en même temps affecter sa valeur à
une autre variable. Dans ce cas, nous devons choisir entre la notation préfixe
et postfixe:

	X = I++	passe d'abord la valeur de I à X et incrémente après
	X = I--	passe d'abord la valeur de I à X et décrémente après
	X = ++I	incrémente d'abord et passe la valeur incrémentée à X
	X = --I	décrémente d'abord et passe la valeur décrémentée à X

Exemple

Supposons que la valeur de N est égal à 5:

	Incrém. postfixe:	X = N++;	Résultat: N=6 et X=5
	Incrém. préfixe:	X = ++N;	Résultat: N=6 et X=6

3.4. Les expressions et les
instructions



Expressions

La formation des expressions est définie par récurrence :

Les constantes et les variables sont des expressions.

Les expressions peuvent être combinées entre elles par des opérateurs
et former ainsi des expressions plus complexes.

Les expressions peuvent contenir des appels de fonctions et elles peuvent
apparaître comme paramètres dans des appels de fonctions.

Exemples

i =0 i++ X=pow(A,4) printf(" Bonjour !\n") a=(5*x+10*y)*2 (a+b)>=100 position!=limite

Instructions

Une expression comme I=0
ou I++ ou printf(...) devient une instruction,
si elle est suivie d'un point-virgule.

Exemples

i=0; i++; X=pow(A,4); printf(" Bonjour !\n"); a=(5*x+10*y)*2;

Évaluation et résultats

En C toutes les expressions sont évaluées et retournent une valeur comme
résultat:

	(3+2==5)	retourne la valeur 1 (vrai)
	A=5+3	retourne la valeur 8

Comme les affectations sont aussi interprétées comme des expressions, il est
possible de profiter de la valeur rendue par l'affectation:

((A=sin(X)) == 0.5)

3.5. Les priorités des opérateurs



L'ordre de l'évaluation des différentes parties d'une expression correspond
en principe à celle que nous connaissons des mathématiques.

Exemple

Supposons pour l'instruction suivante: A=5, B=10, C=1



X = 2*A+3*B+4*C;


L'ordinateur évalue d'abord les multiplications:

2*A ==> 10 , 3*B ==> 30 , 4*C ==> 4


Ensuite, il fait l'addition des trois résultats obtenus:

10+30+4 ==> 44


A la fin, il affecte le résultat général à la variable:

X = 44


Priorité d'un opérateur

On dit alors que la multiplication a la priorité sur
l'addition et que la multiplication et l'addition ont la priorité sur
l'affectation.



Si nous voulons forcer l'ordinateur à commencer par un opérateur avec une
priorité plus faible, nous devons (comme en mathématiques) entourer le terme en
question par des parenthèses.

Exemple

Dans l'instruction:

X = 2*(A+3)*B+4*C;


l'ordinateur évalue d'abord l'expression entre parenthèses,
ensuite les multiplications, ensuite l'addition et enfin l'affectation. (En
reprenant les valeurs de l'exemple ci-dessus, le résultat sera 164)

Entre les opérateurs que nous connaissons jusqu'ici, nous pouvons distinguer
les classes de priorités suivantes:

Classes de priorités


Evaluation d'opérateurs de la même classe

--> Dans chaque classe de priorité, les opérateurs ont la même
priorité. Si nous avons une suite d'opérateurs binaires de la même classe,
l'évaluation se fait en passant de la gauche vers la droite dans
l'expression.

<-- Pour les opérateurs unaires (!,++,--)
et pour les opérateurs d'affectation (=,+=,-=,*=,/=,%=),
l'évaluation se fait de droite à gauche dans l'expression.

Exemples

L'expression 10+20+30-40+50-60
sera évaluée comme suit:

10+20	==>	30
		30+30	==>	60
				60-40	==>	20
						20+50	==>	70
								70-60	==>	10

Pour A=3 et B=4, l'expression A *= B
+= 5 sera évaluée comme suit:

























Pour A=1 et B=4, l'expression !--A==++!B
sera évaluée comme suit:

Les
parenthèses





Les parenthèses sont seulement nécessaires si nous devons
forcer la priorité, mais elles sont aussi permises si elles ne changent rien à
la priorité. En cas de parenthèses imbriquées, l'évaluation se fait de
l'intérieur vers l'extérieur.

Exemple

En supposant à nouveau que A=5, B=10, C=1 l'expression suivante
s'évaluera à 134:

X = ((2*A+3)*B+4)*C

Observez la priorité des opérateurs d'affectation :

X *= Y + 1 <=> X = X * (Y + 1) X *= Y + 1 n'équivaut PAS à X = X * Y + 1











Exercice
3.5










Evaluer les expressions suivantes en supposant

a=20 b=5 c=-10 d=2 x=12 y=15


Notez chaque fois la valeur rendue comme résultat de
l'expression et les valeurs des variables dont le contenu a changé.

(1) (5*X)+2*((3*B)+4) (2) (5*(X+2)*3)*(B+4) (3) A == (B=5) (4) A += (X+5) (5) A != (C *= (-D)) (6) A *= C+(X-D) (7) A %= D++ (8) A %= ++D (9) (X++)*(A+C) (10) A = X*(B<C)+Y*!(B<C) (11) !(X-D+C)||D (12) A&&B||!0&&C&&!D (13) ((A&&B)||(!0&&C))&&!D (14) ((A&&B)||!0)&&(C&&(!D))

Exercice 3.6










Eliminer les parenthèses superflues dans les expressions de
l'exercice 3.5.



3.6. Les fonctions arithmétiques standard



Les fonctions suivantes sont prédéfinies dans la bibliothèque standard <math>.
Pour pouvoir les utiliser, le programme doit contenir la ligne:

#include <math.h>

Type des données

Les arguments et les résultats des fonctions arithmétiques sont du type double.

Fonctions arithmétiques

Remarque avancée

La liste des fonctions ne cite que les
fonctions les plus courantes. Pour la liste complète et les constantes
prédéfinies voir <math.h>.









Exercice
3.7









Essayez le programme suivant et
modifiez-le de façon à ce qu'il affiche:

* A^B,

* l'hypoténuse d'un triangle rectangle de
côtés A et B,

* la tangente de A en n'utilisant que les
fonctions sin et cos,

* la valeur arrondie (en moins) de A/B,

* la valeur arrondie (en moins) à trois
positions derrière la virgule de A/B.

#include <stdio.h>main(){ double A; double B; double RES; /* Saisie de A et B */ printf("Introduire la valeur pour A : "); scanf("%lf", &A); printf("Introduire la valeur pour B : "); scanf("%lf", &B); /* Calcul */ RES = A*A; /* Affichage du résultat */ printf("Le carré de A est %f \n", RES); /* Calcul */ RES = B*B; /* Affichage du résultat */ printf("Le carré de B est %f \n", RES); return 0;}

3.7. Les conversions de type



La grande souplesse du langage C permet de mélanger des données de
différents types dans une expression. Avant de pouvoir calculer, les données
doivent être converties dans un même type. La plupart de ces conversions se
passent automatiquement, sans l'intervention du programmeur, qui doit quand
même prévoir leur effet. Parfois il est nécessaire de convertir une donnée dans
un type différent de celui que choisirait la conversion automatique; dans ce
cas, nous devons forcer la conversion à l'aide d'un opérateur spécial
("cast").

3.7.1. Les conversions de type automatiques



Calculs et affectations

Si un opérateur a des opérandes de différents types, les valeurs des
opérandes sont converties automatiquement dans un type commun.

Ces manipulations implicites convertissent en général des types plus
'petits' en des types plus 'larges'; de cette façon on ne perd pas en
précision.

Lors d'une affectation, la donnée à droite du signe d'égalité est convertie
dans le type à gauche du signe d'égalité. Dans ce cas, il peut y avoir perte de
précision si le type de la destination est plus faible que celui de la source.

Exemple

Considérons le calcul suivant:

int I = 8; float X = 12.5; double Y; Y = I * X;


Pour pouvoir être multiplié avec X, la valeur de I
est convertie en float (le type le plus large des deux). Le résultat de
la multiplication est du type float, mais avant d'être affecté a Y,
il est converti en double. Nous obtenons comme résultat:

Y = 100.00

Appels de fonctions

Lors de l'appel d'une fonction, les paramètres sont automatiquement
convertis dans les types déclarés dans la définition de la fonction.

Exemple

Au cours des expressions suivantes, nous assistons à trois conversions
automatiques:

int A = 200; int RES; RES = pow(A, 2);

A l'appel de la fonction pow, la valeur de A et la
constante 2 sont converties en double, parce que pow est définie
pour des données de ce type. Le résultat (type double) retourné par pow
doit être converti en int avant d'être affecté à RES.





Règles de conversion automatique

Conversions automatiques lors d'une opération avec,

(1) deux entiers:

D'abord, les types char et short sont convertis en int.
Ensuite, l'ordinateur choisit le plus large des deux types dans l'échelle
suivante:

int, unsigned int, long, unsigned long


(2) un entier et un rationnel:

Le type entier est converti dans le type du rationnel.

(3) deux rationnels:

L'ordinateur choisit le plus large des deux types selon l'échelle suivante:

float, double, long double


(4) affectations et opérateurs d'affectation:

Lors d'une affectation, le résultat est toujours converti dans le type de la
destination. Si ce type est plus faible, il peut y avoir une perte de
précision.





Exemple

Observons les conversions nécessaires lors d'une simple division:

int X; float A=12.48; char B=4; X=A/B;

B est converti en float (règle 2). Le résultat de la division
est du type float (valeur 3.12) et sera converti en int avant
d'être affecté à X (règle 4), ce qui conduit au résultat X=3 .

Phénomènes imprévus ...

Le mélange de différents types numériques dans un calcul peut inciter à ne
pas tenir compte des phénomènes de conversion et conduit parfois à des
résultats imprévus ...

Exemple

Dans cet exemple, nous divisons 3 par 4 à trois reprises et nous observons
que le résultat ne dépend pas seulement du type de la destination, mais aussi
du type des opérandes.

char A=3; int B=4; float C=4; float D,E; char F; D = A/C; E = A/B; F = A/C;


* Pour le calcul de D, A est converti en float
(règle 2) et divisé par C. Le résultat (0.75) est affecté à D qui
est aussi du type float. On obtient donc: D=0.75

* Pour le calcul de E, A est converti en int (règle 1)
et divisé par B. Le résultat de la division (type int, valeur 0)
est converti en float (règle 4). On obtient donc: E=0.000

* Pour le calcul de F, A est converti en float (règle
2) et divisé par C. Le résultat (0.75) est retraduit en char
(règle 4). On obtient donc: F=0

Perte de précision

Lorsque nous convertissons une valeur en un type qui n'est pas assez précis
ou pas assez grand, la valeur est coupée sans arrondir et sans nous avertir ...

Exemple

unsigned int A = 70000; /* la valeur de A sera: 70000 mod 65536 = 4464 */








Exercice 3.8









Soient les déclarations:

long A = 15; char B = 'A'; /* code ASCII : 65 */ short C = 10;

Quels sont le type et la valeur de chacune des expressions:

(1) C + 3 (2) B + 1 (3) C + B (4) 3 * C + 2 * B (5) 2 * B + (A + 10) / C (6) 2 * B + (A + 10.0) / C