Vous êtes sur la page 1sur 21

Ministère de l’Enseignement Supérieur

Direction des ISET


ISET Nabeul

Fascicule TP de :

Programmation 1

Réalisé par :
JEBRI Elies

Niveau d’enseignement :
Informatique Premier Niveau

1999/2002
Matière : Programmation C
Professeur : E. JEBRI Travaux Documents Autorisés
Classe : Niveau 1 Durée : 3h
Pratiques de C
Etablissement : ISET Nabeul

Table des matières

Buts de la série 1 Utilisation du debugger


Edition et compilation Recopier un tableau
Messages d’erreur du compilateur Tester des éléments
Aide Somme
"Debugging" Fonction de comparaison
Commentaires Chaînes de caractères
Constantes Déclaration
Sauvegarde Lecture de chaîne
Affichage de chaîne
Notions de la série 2 Longueur de la chaîne
Préparation Renverser la chaîne
Variables et types scalaires Une fonction utile
Opérateurs arithmétiques
Opérateurs relationnels Sujets de la série 5
Affectation Boucles
Opérateurs logiques Une boucle for
Le test: if ... Une autre boucle for
Position du maximum
Notions de la série 3 Visibilité et classes d'allocation
Boucle while
Boucle for Buts de la série 6
Fonctions Instruction «switch»
Lecture de nombre «switch» et les entiers
Calcul «switch» et les caractères
Structures
Notions de la série 4 Définir une structure
Fonctions booléennes Utilisation élémentaire
Test d’intervalle Lire les donnée
Test de majuscules Ecrire
Egalité entre caractères Réponses des devinettes
Tableaux
Déclaration et initialisation

Elies JEBRI 1 Travaux pratiques de C


1 - Buts de la série 1
 Manipulations de fichiers dans l'environnement TURBO C.
 Compiler et exécuter un petit programme.
 Corriger des erreurs.
 Utiliser l’aide.
 Utiliser le DEBUGGER.
 Définir des constantes.
 Mettre des commentaires.
2 - Édition et compilation
 A partir de l’environnement DOS, lancez TURBO C. Notez les commandes
nécessaires.
 Écrivez ce programme :
#include <stdio.h>
main()
{
printf ("Bonjour tout le monde\n");
printf ("Je suis capable de calculer 2+2=%d\n",2+2);
printf ("Au revoir");
}
 Sauvez-le dans un fichier.
 Compilez et exécutez-le.
 Regardez le résultat.
3 - Messages d’erreur du compilateur
Le compilateur signale les erreurs qu’il trouve dans le programme. Des combinaisons
de touches permettent de se rendre directement à la ligne où se trouvait l’erreur.
Notez-les.
Introduisez les erreurs suivantes dans le programme et essayez de le compiler.
 Enlever des guillemets.
 Remplacer "printf" par "print".
 Enlever une accolade.
 Enlever un point-virgule.
4 - Aide
Positionnez le curseur sur l’un des "printf" dans le programme et pressez la
combinaison de touches CTRL+F1. Vous pouvez ainsi obtenir de l’aide sur tous les
éléments du langage.
Les écrans d’aide sont liés entre eux, "voyagez" un peu pour comprendre le système.
Si vous pressez la touche F1 seule, vous obtenez de l’aide sur l’environnement.
Notez comment on peut :
 sélectionner un bloc de texte dans le programme
 déplacer un bloc sélectionné
 copier un bloc sélectionné
 supprimer un bloc sélectionné
 sauver un bloc sélectionné sur disque
 "désélectionner" un bloc de texte.
Expérimentez ces diverses commandes sur votre programme.

Elies JEBRI 2 Travaux pratiques de C


5 - "Debugging"
 Trouvez comment on peut exécuter le programme pas à pas ("pas"="step" en
anglais). Notez-le. Essayez avec votre programme. Une telle fonctionnalité est
très utile pour voir où un programme se plante.
 Mettez un point d’arrêt (breakpoint) sur la seconde instruction "printf" de votre
programme et lancez-le. Il s’arrête automatiquement quand il arrive à cette
ligne. Cette technique est utile si on ne veut examiner qu’une partie du
programme lorsqu’il est long.
 Ajouter la ligne "int ma_variable = 15; "juste après l’accolade ouvrante. Il s’agit
d’une définition de variable entière. TURBO C vous permet d’examiner le
contenu des variables pendant que le programme s’exécute à l’aide du menu
WATCH. Demandez-lui d’observer la variable "ma_variable" et exécutez le
programme pas à pas (step). Vous pourrez voir que la variable vaut 15.
 Ajoutez la ligne "ma_variable=30;" juste après le premier "printf". Il s’agit d’une
affectation qui change la valeur de la variable. Observez ce changement avec
le debug-ger.
 Le debugger permet également d’évaluer des expressions. Évaluez
"ma_variable*3" pendant que vous exécutez le programme pas à pas.
L’observation des variables et l’évaluation des expressions sont très utiles
pour trouver des erreurs dans des programmes qui ne fonctionnent pas.
Souvenez-vous en, vous pourrez gagner beaucoup de temps.
6 - Commentaires
Ajoutez des commentaires dans le programme. Le compilateur les ignore. Mettez
l’une des instructions "printf" en commentaire (rajoutez "/*" avant et "*/" après), le
compilateur ignorera cette ligne. Exécutez le programme, la ligne correspondante ne
doit plus s’afficher. On utilise cette technique pour faire comme si on enlevait un
ensemble de lignes du programme sans l’effacer complètement si l’on est pas sûr de
ce que l’on fait.
7 - Constantes
Définissez la constante "HUIT" avec la valeur 8.
Remplacez l’expression 2+2 dans le deuxième "printf" du programme par la
constante HUIT.
Essayez votre programme, il devrait afficher "...2+2=8" si tout s’est bien passé.
Vous pouvez également lui demander d’afficher la valeur de "ma_variable".
8 - Sauvegarde
Sauvegardez votre travail sur le disque, sur une disquette et essayez de l’imprimer.

Elies JEBRI 3 Travaux pratiques de C


1 - Notions de la série 2
 Entrées et sorties formatées
 Variables, types scalaires et affectation
 Opérateurs arithmétiques, relationnels et logiques
 Le test: if ...
2 - Préparation
Créez un petit programme qui affiche la chaîne "Bonjour" à l'écran et revienne à la
ligne.
3 - Variables et types scalaires
Pour la suite, affichez les valeurs des variables à l'écran en augmentant
graduellement votre pro-gramme.
Retrouvez les trois types scalaires du langage C et définissez une variable de
chaque type, "v_ent" de type entier, "v_reel" de type réel, "v_car" de type caractère.
Souvenez-vous: une variable permet de mémoriser une donnée dans un
programme, sa valeur peut changer au cours de l'exécution.
Les variables peuvent être définies au début du bloc d'instructions du programme
principal (main). Dans ce cas, ce sont des variables locales qui n'existent que dans
ce bloc. Elles peuvent aussi être définies en-dehors de tout bloc, dans ce cas, ce
sont des variables globales, valables dans tout le programme.
Si vous n'initialisez pas les variables, qu'observez-vous lorsque c'est une variable
globale? Et lors-que c'est une variable locale.
Réponse: les variables globales sont automatiquement initialisées à 0, les variables
locales ne le sont pas.
Initialisez, dans la déclaration, l'entier à la valeur 120, le réel à la valeur 20 et le
caractère à la valeur 'x'. Affichez chacun des ces trois types correctement.
La différence entre caractères et entiers est faible en C, affichez-le caractère avec un
"%d" dans la chaîne de format. Vous avez obtenu le code ASCII du caractère 'x'.
Affichez ensuite l'entier, mais avec un "%c" dans la chaîne de format. Que se passe-
t-il?
Cet exercice était censé vous montrer la proximité de ces deux types. Vous ne serez
ainsi pas sur-pris de voir que les opérateurs fonctionnent presque la même chose sur
ces deux types.
4 - Opérateurs arithmétiques
Affichez, avec une seule instruction "printf", la somme et le produit des deux
variables de type entier et réel (les expressions doivent se trouver entre les
parenthèses de la fonction "printf", un nombre quelconque de paramètres est
possible, pour autant qu'il y ait le nombre correspondant de formats dans la chaîne
de format). Utilisez tout d'abord le format "%f" et ensuite le format "%d", qu'observez-
vous, quelle est votre conclusion.
Réponse: un opérateur applique sur un entier et un réel donne un réel.
Affichez ensuite les valeurs suivantes sous leur forme caractère
'a'+1 'a'+2 'Z'-4
Conclusions: les codes ASCII sont ordonnés, les opérateurs arithmétiques
fonctionnent sur les nombres entiers.
Calculez (de tête ou sur papier) les valeurs suivantes
v_ent/7 v_reel/6 v_ent/6 v_ent%12
quel est le type du résultat dans chacun des cas?

Elies JEBRI 4 Travaux pratiques de C


Vérifiez vos calculs à l'aide de votre programme.
Souvenez-vous: la division entre deux nombres entiers donne un nombre
entier (arrondi à l'entier). La division entre un nombre réel et un entier donne
un nombre réel (pas arrondi).
5 - Opérateurs relationnels
Rappel: les opérateurs relationnels retournent une valeur entière, 0 si
l'expression est fausse, autre chose si l'expression est vraie.
Affichez, sous forme décimale et sans utiliser de test, la valeur des expressions
suivantes
v_ent==120 vcar=='x' v_car<'a' v_reel<v_ent v_car>100
La dernière montre que les opérateurs relationnels peuvent être appliqués aux
caractères aussi bien qu'aux entiers. Les opérateurs peuvent être combinés pour
former des expressions plus com-plexes :
v_reel+100!=v_ent v_car-1=='w'+1
Les opérateurs arithmétiques ont une priorité plus grande que les opérateurs
relationnels, et sont donc calculés d'abord.
6 - Affectation
Définissez de nouvelles variables et affectez-leur les expressions que vous avez
écrites jusqu'ici. Vous pouvez utiliser le "debugger" pour examiner leurs valeurs
avant et après l'affectation.
Souvenez-vous: l'affectation est le mécanisme de base pour modifier la valeur
d’une variable au cours du programme.
Avec les définitions de variables
int i=23, b=3; float a=1;
Trouvez l'expression contractée équivalente à
i=12+b a=a*4 b=a-b b=b-a i=2+i i=i+2*a*b-4/i
Réponses :
i=12+b a*=4 b=a-b b-=a i+=2 i+=2*a*b-4/i
Que vaudraient les variables après que l'ordinateur ait exécuté ces opérations si
elles étaient dans un programme?
Solution: si vous n'êtes pas sûr de vous, essayez...
7 - Opérateurs logiques
Déclarez deux variables de type entier (utilisées comme variables booléennes)
v_vrai=1 et v_faux=0.
Ecrivez un petit programme qui affiche une table de vérité contenant les valeurs

v_faux&&v_faux v_faux||v_faux
v_faux&&v_vrai v_faux||v_vrai
v_vrai&&v_faux v_vrai||v_faux
v_vrai&&v_vrai v_vrai||v_vrai
vous devez obtenir
0 0
0 1
0 1
1 1
Souvenez-vous: les opérateurs logiques permet-tent de composer des
prédicats selon les règles "et", "ou" et "non".

Elies JEBRI 5 Travaux pratiques de C


8 - Le test: if ...
Ecrivez un petit programme qui demande un caractère et affiche :
 "OK!" si le caractère est un 'O'.
 "Bof..." sinon.
Modifiez votre programme pour qu'il affiche.
 "OK!" si le caractère est un 'O' ou un 'o'.
 "Bof..." sinon.
Attention, un seul test suffit, utilisez un opérateur logique!
Modifiez votre programme pour qu'il affiche.
 "OK!" si le caractère est un 'O' ou un 'o'.
 "Sorry" si le caractère est un 'N' ou un 'n'.
 "What?" sinon.
Ecrivez un programme qui demande un caractère et affiche
 "MAJUSCULE..." si le caractère est une majuscule (indication: les majuscules
sont toutes entre 'A' et 'Z')
 "minuscule..." si le caractère est une minuscule (indication: les minuscules
sont toutes entre 'a' et 'z')
 "pas une lettre..." sinon.

8 - Exercices à méditer
Exercice n°1 :
Saisir en entrée un nombre entier de 4 chiffres x, il faut ajouter le nombre xreverse
par l’inversion des chiffres de x.
Exemple :
x : 1234
xreverse : 4321
La somme des deux entiers est : 5555

Exercice n° 2 :
Un programme doit calculer la durée qu’un avion met pour parcourir une certaine
distance. Pour cela, on saisit sous forme de nombres entiers la distance (en Km), la
vitesse de l’avion (en Km/h) et la vitesse du vent (en Km/h). La durée du vol doit être
affichée en heures et minutes : HH : MM
Pour la vitesse du vent, une valeur positive signifie vent contraire et une valeur
négative vent en poupe.

Elies JEBRI 6 Travaux pratiques de C


1 - Notions de la série 3
Les boucles: «while» et «for»
Les fonctions.
2 - Boucle while
Ecrivez un petit programme qui demande à l’utilisateur: «Est-ce terminé?» et lise une
réponse sous la forme d’un caractère. Si l’utilisateur répond «n», le programme
recommence. Si l’utilisa-teur répond autre chose, le programme affiche un message
indiquant qu’il a compris ce qu’il devait faire et se termine.
Si vous utilisez une variable, n’oubliez pas que sa valeur est indéterminée si vous ne
l’initialisez pas. Cela pourrait poser des problèmes, par exemple si votre boucle
attend une valeur particulière pour s’exécuter.
Exemple:
Est-ce terminé? n
Est-ce terminé? n
Est-ce terminé? n
Est-ce terminé? o
D’accord, je m’arrête.
Une fois que ce programme fonctionnera de manière satisfaisante, vous allez le
reprendre pour le compliquer un peu.
Votre nouveau programme doit mettre un petit message indiquant qu’il a compris
aussi quand la réponse est «n». Le message ne doit pas être affiché si la réponse
est différente.
Exemple:
Est-ce terminé? n
Ah bon, pas encore!
Est-ce terminé? n
Ah bon, pas encore!
Est-ce terminé? n
Ah bon, pas encore!
Est-ce terminé? o
D’accord, je m’arrête.
Note: la construction «while» toute seule ne permet pas cela.
Votre programme tel qu’il est n’est pas très correct, car l’utilisateur peut taper
n’importe quelle lettre (sauf «n»), et la réponse sera interprétée comme «oui». Ce
comportement est dangereux car plusieurs réponses (dont des idioties ou des fautes
de frappe) donnent le même résultat. Modifiez donc votre programme afin qu’il
redemande la réponse à l’utilisateur si celui-ci n’a pas bien répondu «o» pour «oui»
ou «n» pour «non».
Exemple:
Est-ce terminé? n
Ah bon, pas encore!
Est-ce terminé? k
Répondez par o ou n! l
Répondez par o ou n! m
Répondez par o ou n! n
Ah bon, pas encore!
Est-ce terminé? n
Ah bon, pas encore!
Est-ce terminé? o
D’accord, je m’arrête.

Elies JEBRI 7 Travaux pratiques de C


3 - Boucle for
Une boucle
Ecrivez un programme qui affiche les nombres de 1 à 12 sur la même ligne, puis qu’il
revienne à la ligne. Il faut de plus que chaque nombre soit affiché dans une colonne
de 6 caractères de large.
Et que vous utilisiez la construction «for» pour la boucle.
Deux boucles
Ajoutez une seconde boucle à votre programme pour qu’il souligne la première ligne
avec des caractères ‘=’. Utilisez un «for» et n’affichez qu’un seul caractère ‘=’ dans
chaque «printf».
Des tas de boucles
Ajoutez à votre programme deux boucles imbriquées et affichez la table de
multiplication de 1 à 12.
4 - Fonctions
4.1 - Lecture de nombre
Écrivez une petite fonction «litentier» qui ne prenne pas de paramètre, qui affiche à
l’écran un petit message incitant l’utilisateur à entrer un nombre, qui lise ce nombre
au clavier et qui retourne le nombre lu. Le nombre sera stocké momentanément dans
une variable locale de la fonction.
Vous pourrez tester votre fonction avec le programme de votre choix. Ce programme
devra toute-fois tester trois choses:
 affecter la valeur lue et retournée par la fonction à une variable, puis afficher
la valeur de cette variable.
Note: même si la fonction n’a pas de paramètres, il faut mettre les parenthèses
vides. Bien que contraignante, cette convention permet de distinguer
facilement fonctions et variables.
 Afficher directement à l’écran la valeur retournée par la fonction, donc avec
l’appel de la fonction à l’intérieur de l’appel de «printf».
 Faire un calcul avec la valeur de retour de la fonction. Par exemple
«36*litentier()/(112-b)»
Que se passe-t-il si vous appelez la fonction plusieurs fois dans la même expression.
Par exemple dans «int troisfois=litentier()*litentier()*litentier()»
4.2 - Calcul
Écrivez une fonction «val_absolue» qui prenne un paramètre de type entier et qui
retourne ce nombre sans le signe. Vous pouvez utiliser un test ou toute autre ruse.
La déclaration de cette fonction peut être: «int val_absolue (int);».
Écrivez une petite fonction «distance_i» qui prenne deux paramètres de type entier
et qui retourne la distance qui les sépare. Votre fonction pourra utiliser la fonction de
valeur absolue définie juste avant. Déclaration: «int distance_i (int, int);».
Écrivez une petite fonction qui prenne deux paramètres de type caractères et qui
retourne la dis-tance qui les sépare dans l’alphabet. Sa déclaration pourrait être: «int
distance_c (char, char);».
Cette fonction doit utiliser la fonction «distance_i» déclarée plus haut.
Conseil: utilisez abondamment le «debugger» pour voir comment on entre et
ressort des fonctions, comment elles s’empilent, etc. Une fois cet outil bien en
main, vous perdrez beaucoup moins de temps à chercher les erreurs dans vos
programmes.
Faites quelques tests de votre choix avec ces fonctions.

Elies JEBRI 8 Travaux pratiques de C


5 - Découvrir la fonction rand()
Ecrire un programme C de jeu demandant de deviner un nombre entre 0 et 10 choisi
par l’ordinateur, à chaque essai on lui indiquera si sa proposition est trop petite ou
trop grande. A la fin on indiquera aussi le nombre de tentatives. La solution sera
choisie par l’ordinateur par la fonction rand() qui rend un entier aléatoire (stdlib.h).
Solution = rand()%11 ;

6 - Découvrir la fonction getche()

Un programme doit compter la fréquence des voyelles A, a, E, e, I, i, O, o, U, u dans


une saisie de caractères qui se termine par un point, puis afficher le résultat
graphiquement à l'aide du caractère «#» sous la forme suivante :

A ######### fa%
E ############## fe%
I #### fi%
etc.

Les Séquences pour la même lettre (minuscule ou majuscule) doivent être comptées
ensemble et affichées comme une valeur unique.

Essayez de travailler d’abord avec la fonction de saisie scanf() en fournissant des


phrases d’une longueur importante (plus de deux lignes) que constatez-vous.

Essayez ensuite de substituer la fonction scanf() par getche() (dans la bibliothèque


conio.h), quel est le nouveau résultat obtenu.

Elies JEBRI 9 Travaux pratiques de C


1 - Notions de la série 4
 Encore des fonctions
 Tableaux
 Chaînes de caractères
2 - Fonctions booléennes
2.1 - Test d’intervalle
 Écrivez une fonction «int dans_intervalle (char x, char debut, char fin);» qui
retourne «vrai» (= 1) si «x» se trouve dans l’intervalle entre «debut» et «fin».
Dans le cas contraire, la fonction devra retourner la valeur «faux» (= 0).
A partir de maintenant, vous devrez savoir que «faux» vaut toujours «0» en C
et que toute valeur non nulle est «vraie»!
2.2 - Test de majuscules
Ecrivez une fonction «int majuscule (char x);» qui utilise la fonction précédente et
retourne «vrai» si «x» est une majuscule et «faux» sinon.
2.3 - Egalité entre caractères
Écrivez une fonction «int meme_lettre (char x, char y);» qui retourne «vrai» si «x» et
«y» représentent la même lettre, majuscules et minuscules confondues, «faux»
sinon. La fonction pourra être construite selon les tests suivants :
 Si les caractères sont égaux, retourner «vrai».
 Si une des variables est une majuscule et l’autre une minuscule, alors c’est la
même lettre si la distance entre la majuscule et ‘A’ est égale à la distance
entre la minuscule et ‘a’.
 Sinon, ce n’est pas la même lettre.
3 - Tableaux
3.1 - Déclaration et initialisation
Définissez deux tableau «ta» et «tb» dont les éléments sont des entiers et dont les
tailles sont 10.
Dans la définition de «ta», affectez-lui la valeur «[1, 3, 5, 0, 0, 2, 4, 6, 0, 0]».
Laissez «tb» sans l’initialiser.
3.2 - Utilisation du debugger
Utilisez le debugger pour observer le contenu du tableau.
Quelles valeurs contient «tb»? Pourquoi?
Vous pouvez également, en mettant une valeur entre crochets, observer une seule
composante du tableau. Faites-le pour vérifier si la 7ème composante de «ta» vaut 6.
Souvenez-vous, la nième composante d’un tableau
s’adresse avec l’indice«[n-1]».
3.3 - Recopier un tableau
L’affectation «=» ne fonctionne pas entre les tableaux.
Utilisez donc une boucle pour recopier le tableau «ta» dans le tableau «tb».
3.4 - Tester des éléments
Écrivez un bout de programme (boucle) qui trouve le plus petit indice «i» tel que
«ta[i]==0».
Écrivez un bout de programme (boucle) qui compte le nombre d’éléments non-nuls
dans le tableau «ta».

Elies JEBRI 10 Travaux pratiques de C


3.5 - Somme
Calculez (à l’aide d’une boucle) «s» la somme des éléments du tableau «ta».
3.6 - Fonction de comparaison
L’opérateur de comparaison «==» ne fonctionne pas
pour comparer des tableaux.
Écrivez donc une fonction «egal» qui prenne deux tableaux de 10 entiers comme
paramètre et qui retourne «vrai» si les deux tableaux sont identiques et «faux» sinon.
Idée d’algorithme: prendre une variable «c» comme compteur, initialisée à 0. Si les
cièmes éléments des tableaux sont différents, retourner «faux», sinon, incrémenter «c»
et recommencer. Si «c» arrive à la fin des tableaux sans qu’une différence n’ait été
trouvée, retourner «vrai».
Souvenez-vous de l’importance des boucles dans le traitement des tableaux.
Une boucle «for» avec initialisation «indice=0» et condition de continua-tion
«indice<taille» fonctionne généralement très bien.
Comparez les deux tableaux «ta» et «tb» à l’aide de cette fonction.
4 - Chaînes de caractères
4.1 - Déclaration
Définissez une chaîne de caractères «ch» de longueur 50.
4.2 - Lecture de chaîne
Demandez à l’utilisateur de taper une phrase et utilisez la fonctions «gets» pour
stocker la phrase dans la chaîne «ch».
4.3 - Affichage de chaîne
Utilisez la fonction «printf» pour afficher la chaîne lue.
Utilisez une boucle pour afficher la chaîne caractère par caractère à l’aide de la
fonction «printf» mais en utilisant le format «%c».
4.4 - Longueur de la chaîne
Écrivez une fonction «longueur» qui retourne la longueur d’une chaîne. Déclaration:
«int lon-gueur (char ch[]);». On ne veut pas la longueur totale du tableau, mais
seulement le nombre de caractères avant le terminateur ‘\0’.
Comme les tableaux, les chaînes se manipulent à l’aide de boucles. La plus
utilisée est «while» avec «ch[i]==’\0’» comme condition de fin.
4.5 - Renverser la chaîne
A l’aide d’une boucle, parcourez la chaîne depuis la fin (utilisez la fonction
«longueur» pour trouver la position du dernier caractère non-nul) et affichez-la dans
le sens inverse.
5 - Une fonction utile
Souvent, un programme attend une réponse affirmative ou négative de l’utilisateur
aprés avoir affiché un message du genre «Faut-il continuer (O/N)?» ou «Etes-vous
sûr?». Comme toujours lorsqu’une tâche est répétitive, on écrit une fonction pour
n’avoir à réfléchir qu’une seule fois. On aimerait que cette fonction
 affiche un message
 demande une réponse «oui» ou «non» à l’utilisateur
 informe l’utilisateur si sa réponse n’est pas correcte et lui redemande autant
de fois que nécessaire
 retourne la valeur 0 (faux) si la réponse était «non» ou 1 (vrai) si la réponse
était «oui».

Elies JEBRI 11 Travaux pratiques de C


1 - Sujets de la série 5
 toujours des fonctions...
 boucles
 visibilité
 classes d’allocation
2 - Boucles
2.1 - Une boucle for
Que fait la fonction suivante?
float xxx (a, t)
float a[];
int t;
{
int i;
float b=a[0];
for (i=0; i<t; i++)
if (a[i]>b) b=a[i];
return b;
}
La récrire en utilisant une boucle "do...while". Créer un petit programme de test très
simple.
2.2 - Une autre boucle for
Que fait celle-ci ?
int xxx (c, tab)
char c, tab[];
{
int i;
for (i=0; tab[i] && c!=tab[i]; i++);
return (tab[i])? i : -1;
}
La récrire avec une boucle "do...while" ou une boucle "while" et faire une petit
programme test.
2.3 - Position du maximum
Réalisez, en utilisant les idées des deux fonctions précédentes, une fonction «int
max_loc (int tab[], int taille)» qui reçoive un tableau de «taille» nombres entiers et
retourne la position du plus grand élément. Si plusieurs cases contiennent la valeur
maximale, retourner le plus petit indice.
Testez votre fonction avec le programme suivant :
main()
{
int tab[6] = {4, 2, 8, 1, 8, 3}, pos;
pos = maxloc(tab, 6);
printf ("Position du plus grand élément: %1d, valeur: %1d\n", pos, tab[pos]);
}
il doit retourner Position 2, valeur 8.

Elies JEBRI 12 Travaux pratiques de C


3 - Visibilité et classes d'allocation
Faire un minuscule programme pour tester les choses suivantes, notez vos résultats
et vos conclusions!
- Déclarer une variable globale.
- Déclarer deux fonctions quelconques et une fonction main() qui les appelle.
- Vérifier (avec des printf() ou des putchar()) que toutes les fonctions
connaissent la variables globale.
- Reprendre le programme et vérifier que si la première fonction modifie la
valeur de la variable globale, elle est aussi modifiée dans les autres fonctions.
- Observer que les variables locales de la fonction main() ne sont pas des
variables globales.
- Dans la fonction qui modifie la variable globale, définir une variable locale du
même nom, observer que seule la variable locale est modifiée car elle cache
la définition de la variable globale.
- Renommer la variable locale, observer que la variable globale est à nouveau
modifiée.
- Vérifier que les autres fonctions, même si elles sont appelées par la fonction
qui contient la variable locale ne connaissent pas cette dernière.
Par exemple:
void f1() {
printf ("%d\n",nombre);
}
void f2() {
int nombre=4;
printf ("%d\n",nombre);
f1();
}
ne doit pas fonctionner si nombre n'est pas une variable globale.
- Dans la fonction qui contient la variable locale, mettre un sous-bloc après les
déclarations, observer que la variable locale est connue dans le sous-bloc.
- Observer qu'une modification de la valeur de la variable locale à l'intérieur du
sous-bloc est répercutée à l'extérieur.
- Dans le sous-bloc, définir une variable locale.
- Observer que cette nouvelle variable n'est connue que par le sous-bloc.
- Modifier la définition de cette nouvelle variable et ajouter une expression
d'initialisation qui dépende de la variable locale de la fonction.
Par exemple:
void f2() {
int nombre = 4;
printf ("%d\n",nombre);
{
char c='a' + nombre;
putchar(c);
}
}
- Constater que cette définition est acceptée.
- Rajouter à cette définition une classe d'allocation statique. Constatez que
cette nouvelle définition est refusée par le compilateur. Pourquoi?
- Enlever la référence à la variable locale de la fonction (nombre dans l'exemple
ci-dessus) et constater que cela fonctionne à nouveau, même avec la classe
d'allocation statique. Pourquoi?

Elies JEBRI 13 Travaux pratiques de C


1 - Buts de la série 6
 Instruction «switch»
 Construire un type de données structuré et connaître les opérations possibles.
2 - Instruction «switch»
2.1 - «switch» et les entiers
Transformez l’instruction
int n;
if (n%3==0)
printf ("n est divisible par 3\n");
else
printf ("n n’est pas divisible par 3\n");
en une instruction «switch» équivalente. Cette instruction doit avoir une clause
«default:» pour exprimer le «else» de l’instruction «if».
N’oubliez pas que toutes les instructions sont exécutées après une condition
vérifiée. Il faut donc souvent avoir recours à la rupture «break».
Rajoutez à votre «switch», sans rajouter de «if», deux clauses équivalentes à
if (n%3==1)
printf ("n-1 est divisible par 3\n");
et
if (n%3==2)
printf ("n-2 est divisible par 3\n");
2.2 - «switch» et les caractères
On l’a déjà vu, mais on ne le répète jamais assez, les caractères sont
complètement semblables aux entiers en C.
Déclarez une variable «c» de type caractère et écrivez une instruction «switch» qui
affiche
 «c est une voyelle» si «c» est une voyelle
 «c est une consonne» si «c» est une consonne.
Vous n’aurez besoin que de deux instructions «printf» pour effectuer cette tâche.
3 - Structures
3.1 - Définir une structure
Imaginez que vous écrivez un programme qui ait besoin d’informations
géographiques.
Décrivez une structure «ville» susceptible de contenir pour chaque ville
 le nom (30 caractères)
 la latitude (nombre flottant)
 la longitude (nombre flottant)
 ... tout ce que vous voudrez rajouter d’autre (habitants, pays, etc.)
3.2 - Utilisation élémentaire
 Définissez une variable «struct ville Tunis» dont les champs sont "TUNIS"
(nom), 41 (latitude approximative), 7 (longitude approximative).
 Vous pouvez initialiser un champ après l’autre, ce qui nécessite d’utiliser la
fonction pré-définie «strcpy» pour copier les chaînes puisqu’il n’y a pas
d’affectation entre chaînes en C ou alors initialiser toute la structure d’un coup,
 Essayez ces deux stratégies.
 Comment afficher le champ «nom» de la variable «Tunis» (utilisez «printf»)?
 Comment modifier le champ «latitude»? (par exemple lui affecter la valeur
41.3 si cette valeur est plus exacte.)
 Comment lire une valeur pour le champ «longitude» avec «scanf»?

Elies JEBRI 14 Travaux pratiques de C


3.3 - Lire les donnée
Écrivez une fonction «struct ville lire(void)» qui demande à l’utilisateur les données
de sa ville natale. Votre fonction doit :
 définir une variable de type «struct ville»
 pour chacun des champs de cette variable, demander et lire la valeur, pour
cela, deux stratégies : lire dans une variable temporaire et recopier dans la
structure («strcpy» comme tout à l’heure pour copier les chaînes) ou alors lire
directement avec «scanf».
 retourner la variable à la fonction qui l’avait appelée.
3.4 - Ecrire
Les structures ne font pas partie des types de base imprimables directement avec la
fonction «printf».
Il faut donc, si on veut afficher des structures, afficher chacun de leurs champs
séparément.
Écrivez une fonction «void affiche (struct ville)» qui affiche toutes les informations
contenues dans la variable que vous lui passez en paramètre.
3.5 - Réponses des devinettes
 Initialiser: «struct ville Tunis = { "TUNIS", 41, 7 };»
 Afficher: «printf ("%s", Tunis.nom);»
 Modifier: «Tunis.latitude = 41.3»
 lire: «scanf ("%d", &Tunis.longitude);»

Elies JEBRI 15 Travaux pratiques de C


Matière : Programmation C
Professeur : E. JEBRI
Travaux
Classe : Niveau 1 Pratiques de Durée : 6h

Etablissement : ISET Nabeul Récapitulation

Exercice 1 :

Matrice Notes_classe
Matières Moyenn
e
1 2 3 4 ..... 6
Etudiants étudiant
1 N1,1 N1,2 N1,3 N1,4 N1,6 M1
2 N2,1 M2
3 N3,1 M3
..... .....
6 N6,1 M6

coefficients C1 C2 C3 C4 ..... C6

Moyenne MM1 MM2 MM3 MM4 ..... MM6


par
matière

N3,1 c’est la note de l’étudiant n°3 dans la matière n°1

1. On vous demande d'écrire un programme permettant en premier lieu la saisie de


la matrice Notes_classe contenant les notes de 6 étudiants dans 6 matières
comme montré dans la figure précédente. (Réalisez un affichage cohérent et
clair)
2. Modifiez ce programme de sorte à saisir dans le nouveau tableau coefficients, les
coefficients des matières.
3. Modifiez ce programme pour qu’il calcule la moyenne de chaque étudiant dans
toutes les matières et la place dans le tableau Moyenne_etudiant.
4. Rajoutez la portion de code permettant de calculer les moyennes par matière des
étudiants et de les placer dans le tableau Moyenne_par_matière.
5. Réalisez l’affichage de chacun de ces tableaux.

Elies JEBRI 16 Travaux pratiques de C


Exercice 2 :

Les opérateurs de décalage >> et << sur les bits on la caractéristique de perdre le ou
les bits se trouvant à l’une ou l’autre des extrémités. On se propose donc d’écrire des
fonctions en C permettant d’effectuer un décalage rotatif (càd que les bits éjectés
d’un côté seront réinsérés de l’autre). Ces fonctions devront prendre en paramètre
les bits à décaler et le nombre de décalages.
Les prototypes de ces fonctions sont les suivants :

void decaladroite (int* bin, short nbr) ;


void decalagauche (int* bin, short nbr) ;

où bin est l’entier sur lequel seront appliqués les nbr décalages.

int consom (char* tampon, char* car) ;

Cette fonction renvoie une valeur vraie si le tampon n’est pas vide et fausse sinon.
Ecrivez le corps de cette fonction et faites un exemple d’appel. Les caractères retirés
seront affichés avec la fonction putc().

Elies JEBRI 17 Travaux pratiques de C


Matière : Programmation C
Professeur : E. JEBRI
Travaux
Classe : Niveau 1 Pratiques de Durée : 6h

Etablissement : ISET Nabeul Récapitulation

QUESTION 1
Ecrire un programme qui supprime la première occurrence d'une chaîne de
caractères OBJ dans une chaîne de caractères SUJ.
Exemples :
OBJ SUJ SUJ
pro programme gramme
game amalgame amal

QUESTION 2
On veut écrire un programme pour traiter des jeux de cartes.
A/ Faire une fonction d'affichage qui reçoit en argument un entier NUM et affiche :
 si NUM=1 affiche : "as"
 si NUM entre 2 et 10 : la valeur de NUM
 si NUM=11 : "valet", 12 : "dame", 13 : "roi"
 si NUM=0 : "joker"
B/ Supposons qu’on dispose d'un tableau de 8 entiers nommé TAB, rempli d'entiers
entre 0 et 13 sensés représenter des cartes. Faites une fonction d'affichage des 8
cartes utilisant la question précédente et une boucle.

C/ Faites un programme (avec des fonctions si nécessaire) qui remplit le tableau


TAB (en utilisant un générateur de nombre aléatoires). Attention il ne faut pas avoir
plus de 4 cartes de la même valeur.
Pour générer des nombres aléatoires utilisez la fonction random :
random(val) rend une valeur de type int comprise entre 0 et val-1

D/ Donnez un programme où l'utilisateur joue au jeu de "bataille" contre l'ordinateur.


Le jeu consiste en :
Chacun sort sa première carte. La plus grande gagne. S'il y a égalité, on pose la
carte suivante et c'est la plus grande qui gagne les 4 cartes. Le gagnant est celui qui
à la fin du paquet de cartes en a pris le plus à son adversaire. Le joker est le plus fort
même s’il vaut 0.

Elies JEBRI 18 Travaux pratiques de C


Matière : Programmation C
Professeur : E. JEBRI Documents autorisés
Classe : II 2
Etablissement : ISET Nabeul
TP ANNUAIRE Durée : 6h
Année : 2000/2001

Il s’agit de programmer la gestion d’un petit annuaire téléphonique, contenant un


nombre limité de personnes. Les informations que l’on désire stocker pour chaque
personne sont le nom, le prénom, la date de naissance, la profession, l’adresse et le
numéro de la rue, la ville et le numéro postal et enfin, le numéro de téléphone.

1 - Annuaire : le menu

En vous inspirant de l’exemple du cours, écrivez un programme (principal) qui offre à


l’utilisateur les choix :
• Ajouter un élément (lettre ‘a’)
• Lister des éléments (lettre ‘l’)
• Cherchez un élément (lettre ‘c’)
• Quitter (lettre ‘q’)
Le programme, après avoir affiché les choix possibles, lira la réponse de l’utilisateur
sous la forme d’un caractère.
Le caractère lu sera utilisé comme discriminant pour une instruction «switch» depuis
laquelle vous appellerez des fonctions :
• «ajouter»
• «lister»
• «chercher»
• «quitter»
que vous devrez définir vous mêmes. Pour l’instant, ne vous préoccupez pas de ce
que font les fonctions, il leur suffit d’afficher un petit message (par exemple : printf
("Fonction spécifiée appelée\n");) qui vous permette de voir si votre programme
fonctionne.

2 - Base de données

Pour l’instant, les informations de la base de données seront stockées dans un


tableau, chaque élément de ce tableau étant une structure. Voici donc la structure
des données.
/* nombre maximal de personnes dans l’annuaire */
#define MAX_PERS 5
struct date {
int jour, mois annee ;
} ;
struct personne {
char nom[20], prenom[20] , profession[20], rue[20],
ville[20], telephone[10];
stuct date date_nais ;
int num_rue, num_postal;
};
struct personne annuaire[MAX_PERS];

Elies JEBRI 19 Travaux pratiques de C


La structure «personne» contient les données relatives à une personne et le tableau
«annuaire» contient la liste des informations relatives à chaque personne.
Le nombre de personnes pouvant augmenter en cours d’utilisation, votre programme
doit tenir à jour une variable globale «nb_pers» de type entier indiquant combien de
personnes sont enregistrées.

3 - Fonction «ajouter»

Ajoutez à votre programme la définition de la fonction «ajouter».


Cette fonction doit :
• Demander à l’utilisateur de donner les informations concernant la nouvelle
personne
• Stocker ces informations dans la première «case» vide du tableau.
• Mettre à jour le nombre de personnes.
Il serait également bon que le programme vérifie qu’on essaie pas de mettre plus de
personnes dans l’annuaire que le tableau ne peut en contenir. Si c’est le cas, il
faudra mettre un petit message d’erreur. On peut ici sentir le problème des tableaux :
une fois le programme compilé, la taille du tableau ne peut pas s’adapter à la taille
des données.
Vous pouvez stocker les données dans le bon champ de la structure directement
avec les fonctions «scanf» et «gets».

4 - Fonction «lister»

Avec une petite boucle, la fonction «lister» peut parcourir toute la base de données
et afficher les informations qu’elle y trouve.
Il serait bien que cette fonction signale qu’il n’y a personne dans l’annuaire si on
essaie de le lister quand il est vide.

5 - Fonction «chercher»

On fera la recherche selon trois critères, le nom, la ville et le numéro de téléphone.


Donc vous allez afficher un sous menu :

• Chercher selon le nom (lettre ‘n’)


• Chercher selon la ville (lettre ‘v’)
• Chercher selon le n° de tel (lettre ‘t’)
Le programme, après avoir affiché les choix possibles, lira la réponse de l’utilisateur
sous la forme d’un caractère. Le caractère lu sera utilisé comme discriminant pour
une instruction «switch» depuis laquelle vous appellerez des fonctions :
• «cherche_nom»
• «cherche_ville»
• «cherche_tel»
que vous devrez définir vous mêmes.
Ces trois fonctions devront afficher toutes les données concernant la ou les
personne(s) recherchée(s).

Elies JEBRI 20 Travaux pratiques de C