Considérons la situation suivante:
* La fonction main appelle la fonction FA.
* La fonction FA appelle la fonction FB.
Nous obtenons donc la hiérarchie suivante:
a) Déclarations locales des fonctions et définition 'top-down'
La définition 'top-down' suit la hiérarchie des fonctions:
Nous commençons par la définition de la fonction principale main, suivie des sous-programmes FA et FB. Nous devons déclarer explicitement FA et FB car leurs définitions suivent leurs appels.
/* Définition de main */
main()
{
/* Déclaration locale de FA */
int FA (int X, int Y);
...
/* Appel de FA */
I = FA(2, 3);
...
}
/* Définition de FA */
int FA(int X, int Y)
{
/* Déclaration locale de FB */
int FB (int N, int M);
...
/* Appel de FB */
J = FB(20, 30);
...
}
/* Définition de FB */
int FB(int N, int M)
{
...
}
Cet ordre de définition a l'avantage de refléter la hiérarchie des fonctions: Ainsi l'utilisateur qui ne s'intéresse qu'à la solution globale du problème n'a qu'à lire le début du fichier. Pour retrouver les détails d'une implémentation, il peut passer du haut vers le bas dans le fichier. Sur ce chemin, il retrouve toutes les dépendances des fonctions simplement en se référant aux déclarations locales. S'il existe beaucoup de dépendances dans un programme, le nombre des déclarations locales peut quand même s'accroître dans des dimensions insoutenables.
b) Définition 'bottom-up' sans déclarations
La définition 'bottom-up' commence en bas de la hiérarchie:
La fonction main se trouve à la fin du fichier. Les fonctions qui traitent les détails du problème sont définies en premier lieu.
/* Définition de FB */
int FB(int N, int M)
{
...
}
/* Définition de FA */
int FA(int X, int Y)
{
...
/* Appel de FB */
J = FB(20, 30);
...
}
/* Définition de main */
main()
{
...
/* Appel de FA */
I = FA(2, 3);
...
}
Comme les fonctions sont définies avant leur appel, les déclarations peuvent être laissées de côté. Ceci allège un peu le texte du programme, mais il est beaucoup plus difficile de retrouver les dépendances entre les fonctions.
c) Déclaration globale des fonctions et définition 'top-down'
En déclarant toutes les fonctions globalement au début du texte du programme, nous ne sommes pas forcés de nous occuper de la dépendance entre les fonctions. Cette solution est la plus simple et la plus sûre pour des programmes complexes contenant une grande quantité de dépendances. Il est quand même recommandé de définir les fonctions selon l'ordre de leur hiérarchie:
/* Déclaration globale de FA et FB */
int FA (int X, int Y);
int FB (int N, int M);
/* Définition de main */
main()
{
...
/* Appel de FA */
I = FA(2, 3);
...
}
/* Définition de FA */
int FA(int X, int Y)
{
...
/* Appel de FB */
J = FB(20, 30);
...
}
/* Définition de FB */
int FB(int N, int M)
{
...
}
d) Conclusions
Dans la suite, nous allons utiliser l'ordre de définition 'top-down' qui reflète le mieux la structure d'un programme. Comme nos programmes ne contiennent pas beaucoup de dépendances, nous allons déclarer les fonctions localement dans les fonctions appelantes.
Soient les fonctions main, PI et SURFACE définies par:
#include <stdio.h>
main()
{
double R;
printf("Introduire le rayon du cercle : ");
scanf("%lf", &R);
printf("La surface du cercle est %f. \n",
SURFACE(R));
return 0;
}
double PI(void)
{
return 3.14159265;
}
double SURFACE(double RAYON)
{
return PI()*RAYON*RAYON;
}
a) Etablir la hiérarchie des appels pour les trois fonctions.
b) Définir les fonctions d'après les trois méthodes décrites ci-dessus en ajoutant les déclarations manquantes.
c) Quels messages fournit le compilateur lorsqu'une fonction n'est pas définie ou déclarée avant son appel? Comment peut-on expliquer ces messages?