Université de TOURS - Faculté des Sciences et Techniques

Antenne Universitaire de BLOIS

Licence Sciences et Technologies, Mention Informatique

Module 1 –Informatique – Algorithmique et Programmation Objet

Travaux Pratiques (2), Licence 1ère Année
Mon Premier Programme C

Exercice 1 Exemples de compilations

On considère que l’on a un code source écrit dans le fichier ex1.c.

Expliquer ce qui se passe dans les situations suivantes :

1. je fais gcc ex1.c que se passe-t’il quand j’exécute ex1 ?

2. je fais gcc ex1.c que se passe-t’il quand j’exécute ./ex1 ?
3. je fais gcc ex1.c que se passe-t’il quand j’exécute a.out ?
4. je fais gcc ex1.c que se passe-t’il quand j’exécute ./a.out ?

Exercice 2 Compilation et Construction d’un Makefile simple

Vous allez procéder à l’écriture de votre premier programme en langage C, à sa

compilation et son exécution.

Commencez par écrire le programme en vous servant d’un éditeur (gedit, par
exemple). Donnez-lui le nom hello.c et recopiez-y le texte suivant

Pour le compiler, tapez gcc –Wall hello.c : ceci (gcc) compile le programme
hello.c et génère (si pas d’erreurs) un exécutable appelé par défaut a.out.
Pour exécuter votre programme (exécutable), tapez ./a.out. –Wall indique au
compilateur qu’il affiche tous les warnings-avertissements.
Si vous souhaitez donner un autre nom à l’exécutable, vous pouvez le mentionner
à la suite de l’option –o : gcc –Wall hello.c –o prog1, générera un exécutable
de nom prog1 dont l’exécution se fait en tapant ./prog1.

Un projet est souvent constitué de plusieurs programmes sources C. Pour

illustrer, décomposons notre programme hello.c en 2 programmes comme suit :

Pour compiler (ce "projet"), il faut taper gcc –Wall hello.c affiche.c –o
prog1 et on obtient l’exécutable prog1 qu’on peut exécuter comme
précédemment et obtenir le même résultat.

Travaux Dirigés (8) – Classes et Objets Page 1/5

 Module 1 – Informatique – Algorithmique et Programmation Objet

Ici, il s’agit d’un "projet" constitué que de 2 programmes sources. S’il en

comportait plusieurs dizaines, cela deviendrait fastidieux, d’autant que la mise à
jour (correction, par exemple) d’un seul programme nécessiterait la compilation
de tous les autres.
On peut limiter cela si l’on ne procède à la compilation de chacun des sources
pour produire les fichiers objets et procéder à l’édition de lien à la fin. Par
exemple :
1. gcc –Wall –c hello.c // génère un fichier objet hello.o
2. gcc –Wall –c affiche.c // génère un fichier objet affiche.o
3. gcc –Wall hello.o affiche.o –o prog1 // édition de liens

Testez, vous obtiendrez toujours un exécutable prog1 qui donnera le même

résultat. Dans le cas où un seul programme source est modifié, il est inutile de
compiler les autres. Si hello.c est modifié, il faudra exécuter à nouveau
uniquement les commandes 1. et 3. précédentes, mais ça reste fastidieux.

Il existe un outil, make, qui facilite l’automatiser de la compilation d’un projet.

Nous ne verrons pas en détail ses possibilités mais juste quelques aspects qui
vous feront gagner du temps.

Pour le projet précédent, il nous a fallu exécuter les commandes de 1. à 3. Pour

produire notre exécutable prog1. Suite à la modification de hello.c, il a fallu
exécuter à nouveau les commandes 1. et 3.. Le rôle de make est de reproduire
ces séquences de commandes lors d’événements en fonction des relations entre
les fichiers.

Dans notre exemple, hello.c produit hello.o, affiche.c produit affiche.o et

hello.o et affiche.o produisent prog1. Ces relations, il suffit de les fournir à
make en les décrivant dans un fichier texte Makefile.

Une relation s’écrit sous la forme :

produit : source
commande

elle indique que produit est construit à partir de source et que c’est commande
qui permet de le réaliser.

Nos 3 commandes précédentes peuvent être décrites par les relations suivantes :

prog1 : hello.o affiche.o

gcc –Wall hello.o affiche.o –o prog1

hello.o : hello.c
gcc -Wall –c hello.c

affiche.o : affiche.c
gcc –Wall –c affiche.c

Vous remarquerez que la règle correspondant à la commande 3. est mise en 1er,

car c’est la position de la plus prioritaire, et elle correspond à la construction de
notre projet.

Travaux Dirigés (8) – Classes et Objets Page 2/5

 Module 1 – Informatique – Algorithmique et Programmation Objet

Recopiez les relations précédentes dans un fichier texte nommé Makefile et

lancer make (sans argument) pour compiler votre projet et produire l’exécutable.
Après toute modification de hello.c et/ou affiche.c, il suffit de relancer la
compilation en tapant make et d’exécuter le projet en tapant ./prog1. Ce qui est
plus simple et plus rapide.

Un certain nombre de variables automatiques et de règles implicites existent pour

simplifier l’écriture des fichiers Makefile. Le contenu du suivant (bien que pas
probant) est équivalent au précédent. Recopiez-le et testez.
Pour les plus curieux, consultez la documentation en ligne pour en apprendre
plus.

CC= gcc
CFLAGS= -Wall
objets= hello.o affiche.o

prog1 : $(objets)
$(CC) $(CFLAGS) $(objets) -o $@

hello.o : hello.c
$(CC) $(CFLAGS) -o $@ -c $<

affiche.o : affiche.c
gcc $(CFLAGS) -o $@ -c $<

Exercice 3 Erreurs d’Identificateurs

Commenter et éventuellement corriger le code source suivant :

1. /* Programme de detection des erreurs d ’identificateurs */

2.
3. #include <stdio .h>
4.
5. int maVariable = 10 , MaVariable = 20;
6. float 1resultat_fantastique = 1. * maVariable ;
7. double maVariable = 7.5;
8.
9. int f () {
10. int n = 3;
11. return MaVariable * n ;
12. }
13.
14. double g () {
15. return 4.5 + n ;
16. }
17.
18. int h () {
19. int MaVariable = 4;
20. return 10 * 4;
21. }

Travaux Dirigés (8) – Classes et Objets Page 3/5

 Module 1 – Informatique – Algorithmique et Programmation Objet

Exercice 4 Les entrées/sorties

Les entrées et les sorties standards (depuis le clavier et vers le terminal) peuvent
être réalisées respectivement avec les instructions suivantes :
int printf(const char *format, ...);
int scanf(const char *format, ...);

Exemples :
printf("Bonjour !") ; affichera sur la console le texte "Bonjour !" (sans les "),
printf("La valeur de var est %d", var) ; idem que précédemment mais le %d
sera remplacé par la valeur de var (supposée être une variable entière),

scanf("%d", &var) ; attend que l’utilisateur introduise une donnée (ici supposée
être entière) puis la stocke dans la variable var.

Consultez le manuel pour plus de détails sur leur utilisation.

Ecrire un programme qui demande à l’utilisateur d’introduire une donnée au

clavier et l’affiche sur la console une fois lue. Testez quelques types de données
(entier, réel, …).

Exercice 5

5.1. Écrire le code C dans une méthode main qui permet d’afficher des carrés et des
triangles de taille n (entier introduit par l’utilisateur). Dans les exemples ci-dessous,
n = 4.

**** *
**** **
**** ***
**** ****
Carré de taille 4 Triangle de taille 4

Proposez également une solution itérative (boucle for, par exemple), si vous savez
le faire.

5.2. Écrire un programme qui permet de permuter les valeurs de deux variables entières.
Les 2 valeurs seront demandées à l’utilisateur.
Exemple : soient deux variables a et b avec chacune sa propre valeur initiale. À la fin
de l’exécution du programme, a doit avoir la valeur initiale de b et b doit avoir la valeur
initiale de a.

5.3. Écrire un programme qui permet de permuter les valeurs de trois variables entières.
Les 3 valeurs seront demandées à l’utilisateur.
Exemple : soient trois variables a, b et c avec chacune sa propre valeur initiale. À la
fin de l’exécution du programme, a doit avoir la valeur initiale de b, b doit avoir la
valeur initiale de c et c doit avoir la valeur initiale de a.

5.4. Écrire un programme qui calcule la surface et le volume d’un parallélépipède rectangle
à partir des valeurs de longueur, largeur et hauteur saisies par l’utilisateur.
Rappel : La surface d’un parallélépipède rectangle est égale à la somme des surfaces
de ses six faces. Son volume est égal à longueur*largeur*hauteur.

Travaux Dirigés (8) – Classes et Objets Page 4/5

 Module 1 – Informatique – Algorithmique et Programmation Objet

5.5. On rappelle que si n et d sont des entiers naturels avec d ≠ 0, la division euclidienne
de n par d consiste à trouver q et r entiers naturels tels que n = q * d + r avec r
< d. n est le dividende, d le diviseur, q le quotient et r le reste.
Exemple : si n = 29 et d = 3, on aura q = 9 et r = 2.

Écrire un programme qui demande les valeurs de n et d, calcule q et r et les

affiche. Utiliser pour cela les opérateurs / et %.
Rappel : / est la division entière et % est le reste de la division Euclidienne.
53 / 10 = 5 et 53 % 10 = 3.

5.6. En utilisant les opérateurs / et %, écrivez un programme qui demande à l’utilisateur

d’introduire un entier de 4 chiffres et qui affiche chacun de ses chiffres.
Exemple :

5.7. En utilisant les opérateurs / et %, écrivez un programme qui demande à l’utilisateur

d’introduire un entier de 4 chiffres et qui affiche la somme de ces derniers.
Exemple : Si le nombre introduit est 1234, le programme devrait afficher une somme
égale à 10 ( 1 + 2 + 3 + 4 = 10 ).

5.8. Généralisez le programme précédent de façon qu’il fasse la même chose pour un
entier d’un quelconque nombre de chiffres.

5.9. Écrivez un programme qui demande à l’utilisateur d’introduire une valeur (multiple de
5) représentant une somme d’argent et qui calcule et affiche le nombre de billets de
100, 50, 20, 10 et 5 euros qu’elle représente (en privilégiant le minimum de billets).
Exemple :

5.10. Écrire un programme qui demande à l’utilisateur d’entrer une durée en seconde et qui
affiche la durée en heures, minutes et secondes. Les parties heure et minute ne seront
affichées que si elles sont supérieures à 0.
Exemple :

Travaux Dirigés (8) – Classes et Objets Page 5/5