Procédures
&
Fonctions
Accueil

du site

L'idée initiale est d'attacher un identificateur à certaines séquences de code d'usage fréquent, afin de pouvoir les appeler à l'aide de cet identificateur au lieu de les réécrire à chaque fois.

Il y a deux manières très différente de procéder : les macroinstructions ou macros et les procédures ou fonctions.

La première, pouvant parfois rendre quelques services, est peu efficace et peut provoquer des erreurs.
Il est indispensable de la connaître car vous risquez de la rencontrer. Voir macros.

Dans cette page, nous ne nous occuperons que des procédures et des fonctions. Une différence existe entre les deux concepts, elle se précisera plus tard.

Jusqu'à présent, nous avons utilisé pluieurs fois des procédures telles que printf("Salut !"); putchar('a'); etc.
Nous allons voir maintenant comment on les écrit.

Une fonction mathématique

Supposons que nous souhations calculer les solutions d'une équation du second degré du type :
ax2 + bx + c = 0
et afficher ces racines qui sont données par :



Notre intention est de faire un programme qui nous affiche les valeurs des racines quand il y en a.
D'abord, nous écrivons le code de résolution de l'équation sans penser à utiliser
la notion de fonction.

Notes :
Le signe de multiplication est l'étoile.
Le signe de division est ' / '
La racine carrée s'obtient grâce à la fonction sqrt( )
de la librairie "math" livrée avec le compilateur

#include <stdio.h>
#include <math.h>

int main()
{
-double a,b,c, determinant, racine1,racine2;
-bool aRacines;

-//Calcul :
-a = 1.0 ; b = -11.2 ; c = -31.05 ;
-determinant = b*b - 4*a*c;
-if(determinant < 0)
-{
--aRacines = false;
--printf("Pas de racines\n,");
-}
-else
-{
--aRacines = true;
--if(determinant > 0)
--{
---racine1 = (-b + sqrt(determinant))/(2*a);
---racine2 = (-b - sqrt(determinant))/(2*a);
---printf("Racine 1 = %f \n", racine1);
---printf("Racine 2 = %f \n", racine2);
--}
--else //Forcément determinant == 0 !
--{
---racine1 = racine2 = - (b/2*a);
---printf("Deux racines égales : %f \n", racine1);
--}
-}
}

Imaginez la lonueur du programme s'il fallait afficher les racines
de plusieurs équations !

Voici maintenant un programme poursuivant le même but,
mais qui commence par écrire quelques fonctions.

#include <stdio.h>
#include <math.h>

// Ci-dessous la déclaration de la fonction "determinant"
// On lui passe les paramètres suivants :
// a, b, c séparés par des virgules à l'intérieur des parenthèses
// Chaque paramètre est précédé de son type (ici double)
// Le type double placé avant l'identifiant determinant est là pour
// indiquer que cette fonction retourne un nombre de type double
// --------------------------------------------------------------------------
double determinant(double a, double b, double c)
{
-return(b*b - 4*a*c);
}

double Racine1(double a, double b, double c)
{
-return (-b + sqrt(determinant(a,b,c)))/(2*a);
}

double Racine2(double a, double b, double c)
{
-return (-b - sqrt(determinant(a,b,c)))/(2*a);
}

// La différence entre une fonction et une procédure
// est qu'une procédure ne retourne pas de valeur.
// C'est ce qu'indique le mot réservé "void" placé avant l'identifiant
// Cette procédure reçoit également les trois paramètres a,b,c
// et elle ne fait qu'afficher les données souhaitées.
// -------------------------------------------------------------------
void AfficheRacines(double a, double b, double c)
{
 -double d = determinant(a,b,c);
-if( d < 0) printf("Pas de racines\n");
-else
- -if(d >0)
- -{
- - printf("Racine 1 = %f\n",Racine1(a,b,c));
- - printf("Racine 2 = %f\n",Racine2(a,b,c));
- -}
- -else
- - -printf("Racine double : %f\n",Racine1(a,b,c));

-putchar('\n'); //Aller à la ligne pour séparer de la suite
}

//Voyez avec quelle facilité nous allons pouvoir afficher
//autant d'équations que nous le voudrons :

int main()
{
-AfficheRacines(1.0,-11.2,-31.05);
-AfficheRacines(1.0,-21,110.25);
-AfficheRacines(1.0,-5.36,8.32);

-return 0;
}

Affichage obtenu :

Racine 1 = 13.500000
Racine 2 = -2.300000

Racine double : 10.500000

Pas de racines

Press any key to continue

Notez les avantages que présentent les procédures :

  • les difficultés de programmation et risques d'erreur sont divisés par autant de procédures : fiabilité
  • chaque procédure pourra être réutilisée sans avoir à la réécrire : gain de temps, disponibilité
  • le programme principal est bien plus lisible : clarté

Déclaration et appel typiques d'une fonction


Déclaration d'une fonction :

//Dans ce qui suit, les contenus entre crochets [ ] peuvent être répétés autant de fois que l'on veut..

type IdentifiantDeLaFonction( type parametreFormel [, type parametreFormel])
{
--- instruction;
---[instruction;]
}

Appel d'une fonction :

variable = IdentifiantDeLaFonction( parametreReel [, parametreReel] ) ;

Les paramètres utilisés à la déclaration de la fonction servent à écrire le code de cette fonction.
On les appelle paramètres formels.

Les paramètres que l'on passe à la fonction lorsqu'on l'appelle, sont appelés paramètres réels par ce que c'est sur ceux-là que la fonction va réellment effectuer ses calculs.

Paramètres réels et formels n'ont généralement pas les mêmes identifiants.

Il y a beaucoup de choses à dire en ce qui concerne l'usage des paramètres
dans les fonctions et procédures.
Reportez-vous à la page :
Paramètres

La suite : paramètres
Macros
Sommaire Langage C
Accueil

du site