Rado A. Rakotonarivo

« Retour

Vous trouverez les énoncés des TD sur le moodle du cours ici.

TP 4 : Tableaux, fonctions et menus

Fonctions

Quoi ? on peut voir les fonctions comme des sous-programmes cad : une suite d’instructions qui effectue une tache précise.

• une fonction peut/peut ne pas prendre des paramètres en entrée (arguments)
• une fonction peut/peut ne pas renvoyer une valeur en sortie (valeur de retour)

Pourquoi ?

• factorisation du code : regrouper dans une fonction des blocs identiques (éviter de réécrire dans un même programme des bouts de codes identiques)
• réutilisation : une même fonction peut être utilisée par plusieurs programmes (bibliothèque)
• lisibilité : (nommée de façon explicite) facilite la lecture du code en cachant les détails de codage
• structuration : permet de travailler à plusieurs, découpage en sous-problème

Comment ? (1) déclaration (2) définition (3) appel

-- Déclaration --
type_de_retour nom_fonction (type1 arg1, type2 arg2, ... );

On parle également de prototype de la fonction. Si la fonction ne renvoie pas de valeur le type de retour sera void : par convention on dira que c’est une procédure.

-- Définition --
type_de_retour nom_fonction (type1 arg1, type2, arg2, ... ) {

  /* corps de la fonction */

  return (une valeur de type type_de_retour);
}

C’est à ce moment que l’on va dire de manière explicite ce que fera la fonction.

-- Appel --
nom_fonction(arg1, arg2, ...);

Quand on utilise une fonction, on dit qu’on fait un appel à la fonction.

La première fonction que l’on a rencontré est la fonction main. Examinons sa définition.

int main () {
  // code
  return EXIT_SUCCESS;
}

On sait désormais que la fonction nommée main:

• a pour type de retour un entier (int)
• ne prend pas d'arguments (pour l’instant)
• a pour valeur de retour EXIT_SUCCESS qui est donc un entier

Tous les commentaires superflus que l’on a vu dans les exercices précédents prennent maintenant leur sens. Ils indiquent à quels moment, et dans quel endroit de notre code source nous devons déclarer, définir et appeler des fonctions. Voyons cet exemple.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include<stdio.h> /* printf est déclarée ici */
#include<stdlib.h> /* EXIT_SUCCESS est déclarée ici */

/* Déclaration des fonctions utilisateur */
int toto (int x, int y);

/* Fonction principale */
int main () {

  int a = 2, b = 3, c;

  c = toto(a, b); //appel de la fonction toto avec comme arguments a et b

  printf("toto de %d et %d vaut %d\n", a, b, c); //

  return EXIT_SUCCESS;
}

/* Définition des fonctions utilisateur */
int toto (int x, int y) {         // toto(2, 3)
  int res = x + y;
  return res;                   
}

Les fonctions utilisateur dont il est question ici sont les fonctions que nous allons écrire dans nos programme. On sait désormais que les déclarations de fonctions se font avant le main, les définitions se font après le main et les appels se font ... à l'intérieur d'une autre fonction.

Pour l’instant, nous allons nous contenter de cette structure. Mais nous verrons plus tard qu’on peut déclarer et définir nos fonctions ailleurs (rappelez-vous que printf est définie autre part). À ce moment nous aussi nous pourrons utiliser ce pourquoi des fonctions en écrivant nos propres bibliothèques de fonctions.

Pour être sur de bien comprendre. Regardons la trace du programme.

main()
----------------------------------------------
| lignes | a | b | c |      Affichage        |
----------------------------------------------
|  init  | 2 | 3 | ? |                       |
|   12   |   |   |   |                       | toto (2,3)
---------------------------------------------------------------------------------
|                                            | lignes | x | y | res | Affichage |
|                                             ------------------------------------
|                                            |  init  | 2 | 3 |     |           |
|                                            |   21   | 2 | 3 |     |           |
|                                            |   22   | renvoie 5               |
---------------------------------------------------------------------------------
|   12   |   |   | 5 |                       |
|   14   |   |   |   | toto de 2 et 3 vaut 5 |
|   16   | renvoie EXIT_SUCCESS              |
----------------------------------------------

Une fois arrivé à la ligne 12, le programme fait un appel à la fonction toto. À partir de ce moment l'exécution de notre programme saute directement à la ligne 20 pour aller exécuter les instructions se trouvant dans la définition de la fonction toto. Enfin quand cette dernière renvoie une valeur (termine son execution), elle retourne cette valeur vers la fonction qui l'a appelée. L'exécution du programme reprend alors dans le main en affectant dans la variable c la valeur renvoyé par toto.

Revoyez les exercices du TD8 pour être sûrs de bien comprendre 😉

Menu

Dans les TP précédents, vous avez réalisé plusieurs programmes en C effectuant chacun une tâche. Le but de ce TP est d'utiliser des fonctions pour commencer à réunir plusieurs de ces programmes en un seul, dans lequel l'utilisateur choisira la tâche à effectuer dans un menu. À la fin de l'exécution d'une tâche, le menu est à nouveau affiché pour laisser le choix à l'utilisateur d'exécuter d'autres tâches ou de quitter le programme.