Buts des séances 7 et 8

• Etre capable d'utiliser les routines de gestion d'entrées/sorties simples en C
• Etre capable de traduire en C des algorithmes de petite taille portant sur des séquences
• Maîtriser les traductions des différentes formes itératives algorithmiques (répéter, tant que, etc)

1- Fonctions d'entrées-sorties

Le langage C fournit un ensemble de librairies dont certaines sont relatives aux entrées-sorties. Ces fonctions permettent l'échange d'information entre l'ordinateur et les périphériques standards d'entrées-sorties (clavier, écran). Parmi l'ensemble des fonctions fournies, nous nous restreignons aujourd'hui à deux fonctions essentielles (scanf et printf) permettant de manipuler des chaînes de caractères, des caractères ou des valeurs numériques.

Le fichier include généralement employé pour les entrées-sorties est stdio.h. Si l'on souhaite utiliser les fonctions d'entrée-sortie dans un module M.c, alors il faut inclure la directive suivante dans le module M.c:

     .....

 /**************************************************************************************************/
/*                                                                                  Fichiers inclus                                                                      */
/**************************************************************************************************/
#include <stdio.h>

    ....

1.1 La fonction scanf

Il est possible de faire lire par l'ordinateur des données en entrée par la fonction scanf, qui permet de saisir des valeurs numériques, des chaînes ou des caractères. La syntaxe de la fonction est la suivante :

scanf (format, arg0, arg1, arg2, ', argn)

 
Le paramètre format est une chaîne qui contient les informations permettant à l'ordinateur d'analyser les données lues en entrée. Les paramètres arg0, .., argn représentent les données qui nous intéressent parmi celles lues en entrée.

Le format se compose d'une série de groupes de caractères commençant généralement par %. De manière simple, tout % est suivi d'un ou plusieurs caractères indiquant le type de la donnée attendue (%lu indique une valeur entière non signée, %c indique un caractère, etc). Par exemple, l'instruction suivante permet au programme de lire une valeur de type entière saisie au clavier, et de placer cette valeur dans la variable entier_non_signe (la signification du symbole & précédent le nom de cette variable sera vue ultérieurement).

scanf ( " %lu ", &entier_non_signe) ;

 
Au sein d'une chaîne de format, les groupes de caractères peuvent être contigus ou séparés par des espaces. Lorsque des espaces apparaissent dans la chaîne de format, tous les caractères d'espacement (y compris les retours à la ligne) correspondant qui sont lus dans les données saisies sont ignorés. Par exemple, l'instruction suivante implique que l'utilisateur saisisse trois caractères de manière contigue au clavier. Si l'utilisateur saisit le caractère 'a' puis espace puis 'b' puis espace puis 'c', alors car1 contiendra 'a', car2 contiendra l'espace, et car3 contiendra 'b'.
 

scanf ( " %c %c %c ", &car1, &car2, &car3) ;
 

Parmi les principaux groupes de caractères utilisés comme spécificateurs de type, on distingue deux principales catégories.

• Les spécificateurs de type
• c caractère
• s chaîne
• d entier décimal signé
• u entier décimal non signé
• o entier octal
• x entier hexadécimal
• f virgule flottante

• Les spécificateurs de taille
• Ceux qui peuvent être utilisés lorsque le type est s
• Nombre-de-caractères. Par exemple, scanf(" %32s ", chaîne) permet de saisir une chaîne qui contient au maximum 32 caractères. Si des caractères supplémentaires sont tapés par l'utilisateur, ils sont ignorés.

• Ceux qui peuvent être utilisés lorsque le type est d, u, o, x, ou f
• l (long) pour les entiers longs ou les flottants longs
• h (short) pour les entiers courts

scanf(" %s%hd%f ", piece, &reference, &prix)          saisie d'une chaîne suivie d'un entier court puis d'un réel court

scanf(" %ld ", &entier_long_signe)                            saisie d'un entier long signé

scanf(" %lf ", &double)                                                saisie d'un réel long

 
En outre, lors de la saisie de chaînes de caractères, on peut également préciser quels sont les caractères acceptés (%[a-z] n'accepte que les minuscules), ou bien ceux qui doivent être considérés comme des séparateurs (%[^\n] précise que le caractère qui sera considéré comme séparateur sera le retour à la ligne (par exemple %200[^\n] indique que l'on veut saisir une chaine d'au plus 200 caractères, dont le délimiteur est le retour chariot).

1.2 La fonction printf

La fonction printf permet à l'ordinateur d'écrire des données sur l'unité de sortie standard (écran). Cette fonction effectue l'inverse de la fonction scanf. Sa syntaxe est la suivante :

printf( format, arg0, arg1, arg2, .., argn)

Le paramètre format contient à la fois du texte et des spécificateurs de format, qui précisent comment seront affichées les valeurs arg0, ; ;,argn. Les spécificateurs de type et taille sont globalement similaires à ceux utilisés par le scanf. Par exemple :

 

EXERCICE   Rapatriez les fichiers requis pour la partie IV du stage de rentrée à l'URL :  http://sirac.inrialpes.fr/~boyer/cours/CCI (sélectionnez RENTREE4.tar.gz). Les fichiers récupérés contiennent des exemples de modules effectuant des entrées/sorties.  Lire et comprendre les exemples. Les compiler et les exécuter. Ecrire un nouveau programme qui affiche à l'écran la phrase " Quel est l'age du capitaine ' ", puis saisit cet âge dans une variable entière, puis affiche " Quel est le nom du capitaine ", saisit son nom dans un tableau de caractères et enfin récapitule les informations saisies en les affichant. Compiler et exécuter ce programme. Compléter le programme précédent en demandant à l'utilisateur de saisir l'adresse du capitaine. Attention, l'adresse est une suite de mots séparés par des espaces. Il faut donc préciser à la fonction scanf de ne considérer que le retour à la ligne (\n) comme séparateur. Compiler et exécuter le nouveau programme. Ecrire un programme qui simule une calculette. Les informations lues sont une suite de trois caractères composée d'un chiffre, un symbole d'opération (+ ou -) et un autre chiffre. Le programme affiche le résultat de l'expression donnée. Ecrire un programme qui demande à l'utilisateur de saisir une suite de valeurs entières strictement positives. Les valeurs entières sont séparées par des espaces, et la valeur 0 est utilisée pour marquer la fin de la suite.  Si le temps vous le permet, vous pouvez essayer de transformer le programme précédent pour permettre la saisie d'une suite de valeurs entières quelconques. Les valeurs entières sont toujours séparées par des espaces, mais le caractères '*' est cette fois utilisé pour marquer la fin de la suite. La marque de fin de suite étant cette fois un caractère, on ne peut donc plus saisir les valeurs entières au moyen du format %l. Il est nécessaire de saisir une suite de chaînes de caractères (format %s) puis de transformer chaque chaîne en la valeur entière correspondante. Cette transformation est réalisée par la fonction atol (faire man atol).

 

2-Forme binaire (E2.9)

On demande de traduire l'algorithme Forme binaire d'un entier (E2.9) en un programme C interactif qui saisit une suite de 0 et 1 et construit l'entier dont c'est la représentation binaire. La fin de la suite est marquée par l'entier 2.
La traduction de l'instruction répétitive Tant Que pourra utiliser l'instruction while de C, dont la syntaxe est la suivante :

  while (condition)
     instruction

lire_ent_bin : une action (le résultat : un entier valant 0, 1 ou 2)

Lexique

ent : un entier
saisir : une action (le résultat : un entier)*

répéter
écrire (" tapez un entier (0, 1 ou 2) : ")
lire(ent)
tantque (ent < 0) ou (ent > 2)

Lexique
marque : l'entier 2
ec : un entier >= 2
nb : un entier >= 0
Algorithme
écrire(" ************************************** ")
écrire(" * Forme binaire d'un entier * ")
écrire(" ************************************** ")
écrire(" tapez une suite de nombres positifs ", marque, " indiquant la fin de la suite ")
nb <- 0
lire_ent_bin(ec)
tantque ec <> marque
nb <- nb * 2 + ec
lire_ent_bin(ec)
écrire(" le nombre represente par la suite est ", nb)

3-Nombre d'eléments d'une séquence (E2.8)
 
 

EXERCICE  Ecrire le programme nb_elt.c, qui permet à l'utilisateur de saisir une suite de valeurs entières positives et qui affiche le nombre d'éléments faisant partie de cette suite. La marque de fin de suite est 0. Procéder par similarité avec le programme précédent. Compiler et exécuter le programme nb_elt.

 

4-Nombre d'occurrence de la valeur maximum dans une séquence d'entiers (E2.4)
 
 

EXERCICE  Ecrire le programme nb_occ.c, qui permet à l'utilisateur de saisir une suite de valeurs entières positives, et qui affiche ensuite le nombre d'occurrences de la valeur maximum dans cette suite. La marque de fin de suite est le 0. Compiler et exécuter le programme nb_occ.

 

On souhaite écrire un programme qui permet à l'utilisateur de saisir un caractère, et qui informe ensuite l'utilisateur si le caractère saisi est une consonne. L'algorithme général de ce programme est le suivant.

Algorithme principal

Lexique

lettre : un caractère
i : un entier sur [1..21]
t_cons : un tableau sur [1..21] de caractères
Saisir : une action (le résultat : un caractère)
ecrire : une action (la donnée : un texte)

écrire(" ************************************** ")
écrire(" * une lettre est-elle une consonne * ")
écrire(" ************************************** ")
écrire(" tapez une lettre (0 pour sortir du programme) ")
saisir(lettre)
tantque lettre <> '0'
i <-0
tantque (i < 21) etpuis (t_cons i <> lettre)
i <- i + 1
si t_cons i = lettre
ecrire(" La lettre ", lettre, "est une consonne ")
sinon
ecrire(" La lettre  " , lettre, " n'est pas une consonne ")
ecrire(" Tapez une lettre (0 pour sortir du programme ")
saisir(lettre)

On souhaite écrire un programme qui permet à l'utilisateur de saisir une suite d'entiers (dont la marque de fin est le caractère '*'), qui place cette suite dans un tableau et détermine ensuite si la suite est triée en ordre croissant, ou décroissant, ou bien non triée.

L'algorithme principal est constitué des étapes suivantes :

1. Saisie de la suite d'entiers et rangement dans un tableau
2. Affichage de la suite saisie
3. Détermination d'un ordre éventuel sur la suite
4. Affichage du résultat

La séquence saisie sera placée dans un tableau, à partir duquel sera effectué son tri par la méthode du tri par recherche du minimum. L'algorithme correspondant à cette méthode est donné ci-après.

Lexique