Année universitaire 2002-2003 |
Licence d'informatique
|
La conversion d'un type vers un autre s'effectue en faisant précéder la valeur à convertir du nouveau type entre parenthèses.
char car='a';
int i=0;
float r;
r=(float)i;
i=(int)car; /* i reçoit le code ASCII du caractère 'a'. */
Certaines conversions peuvent générer des résultats inattendus, comme dans l'exemple suivant :
char car;
int i=13257; /* Un entier est codé sur 16 ou 32 bits. */
car=(char)i; /* Un caractère étant codé sur 8 bits (1 octet),
la conversion risque de causer une perte d'information. */
Il a déjà été dit que l'instruction :
est équivalente à :
Les expressions expr1, expr2 et expr3 peuvent être absentes. Si expr2 est absente, cela signifie que la condition est vraie en permanence.
for (;;) action; est une boucle infinie.
Dans une boucle for, deux expressions séparées par une virgule sont évaluées de la gauche vers la droite. La virgule permet de gérer notamment deux indices en parallèle dans une seule boucle for.
Langage C |
Équivalent Ada |
Équivalent Pascal |
for (i=0,j=20;j>i;i+=5,j+=2) ; |
i:=0; j:=20; while j>i loop i:=i+5; j:=j+2; end loop; |
i:=0; j:=20; WHILE j>i DO BEGIN i:=i+5; j:=j+2 END |
1) Écrire un programme, utilisant une boucle while, qui affiche une table de conversion des degrés Farenheit en degrés Celsius, de la forme suivante :
> td02ex01 Farenh. - Celsius 0 - -17 20 - -6 40 - 4 60 - 15 <...> 300 - 148 > |
Remarques :
C=(5/9)*(F-32)
2) Reprendre l'exercice précédent en remplaçant la boucle while par une boucle for.
La structure d'une fonction en C (selon la norme ANSI) est de la forme suivante :
type_retourné nom_fonction(liste_paramètres_typés)
{
...
/* Corps de la fonction. */
return(valeur); /* On
peut aussi écrire : return valeur; */
}
Langage C |
Équivalent Ada |
Équivalent Pascal |
void fonct(int a,int b,float r) { char car; /* Variable locale. */ car=getchar(); printf("%d %d %f %c\n",a,b,r,car); } |
procedure proc(a,b:in integer;r:in float) is car:character; begin get(car); put_line(integer'image(a)&integer'image(b) &float'image(r)&' '&car); end proc; |
PROCEDURE proc(a,b:INTEGER;r:REAL); VAR car:CHAR; BEGIN read(car); writeln(a,' ',b,' ',r,' ',car) END; |
Si type_retourné vaut void (qui signifie "vide" en anglais), alors la fonction ne renvoie pas de valeur. Dans ce cas :
return;
L'affectation d'une valeur v à une variable x se décompose en deux phases :
Écrire un programme qui, après avoir lu un texte contenant
moins de 100 caractères se terminant par un caractère $
(ce texte sera stocké dans un tableau), inverse l'ordre des caractères
de ce tableau, puis affiche le texte inversé.
Exemple :
Dans un programme en C, le passage des paramètres à une fonction ne peut pas se faire "par adresse" (modes out ou in out de l'Ada ; mot-clé VAR du Pascal), mais seulement "par valeur", sauf pour les tableaux (cf. le paragraphe 6 de la séance 3 de travaux dirigés). Par exemple, le programme suivant affiche bien à l'écran 6 est le triple de 2 :
#include <stdio.h> int triple(int a) { a=a*3; return(a); } int main(void) { int b=2; printf("%d est le triple de %d\n",triple(b),b); return(0); } |
et la valeur de b n'est pas modifiée après l'appel à la fonction triple.
Pour que la valeur d'une variable soit modifiée par un appel
à une fonction, il faut lui transmettre l'adresse de cette variable
dans la mémoire. Lorsqu'on déclare int a;
le système réserve un espace suffisant dans la mémoire
pour ranger un entier. L'adresse de cet espace réservé est &a. Ainsi, lorsqu'on veut lire une valeur entière tapée
au clavier, on utilise généralement l'instruction scanf("%d",&a); donc pour que la valeur de la variable a soit
effectivement modifiée par cette opération de lecture, il
faut en passer l'adresse &a, d'où les équivalences
suivantes :
Langage C |
Équivalent Ada |
Équivalent Pascal |
scanf("%d",&a); | get(a); | read(a) |
printf("Valeur : %d",a); | put("Valeur : "&integer'image(a)); | write('Valeur : ',a) |
On a déjà vu le fonctionnement du buffer d'entrée durant la première séance de travaux dirigés. La fonction getchar permet de lire le caractère le plus ancien du buffer d'entrée. La fonction scanf permet elle aussi de lire des caractères dans le buffer d'entrée, mais sa description est un peu plus compliquée :
scanf("%d",&i);
printf("Entier : %d\n",i);
Si l'utilisateur tape <espace>10abc<retour-chariot>, le buffer d'entrée étant vide, alors on aura l'affichage suivant :
Entier : 10
et il restera les caractères abc<retour-chariot> dans le buffer d'entrée.
scanf("%f",&r);
printf("Réel : %f\n",r);
Si l'utilisateur tape <retour-chariot>10.01fin<espace><retour-chariot>, le buffer d'entrée étant vide, alors on aura l'affichage suivant :
Réel : 10.010000
et il restera les caractères fin<espace><retour-chariot> dans le buffer d'entrée.
scanf("%d",&i);
printf("Entier : %d\n",i);
Si l'utilisateur tape <espace>abc<retour-chariot>, le buffer d'entrée étant vide, alors on aura un affichage aberrant, comme par exemple :
Entier : -268436884
Écrire un programme C qui calcule la factorielle d'autant de nombres lus au clavier que demandé par l'utilisateur. Utiliser une fonction pour le calcul de la factorielle.