10.4. Renvoyer un résultat

Par définition, toutes les fonctions fournissent un résultat d'un type que nous devons déclarer. Une fonction peut renvoyer une valeur d'un type simple ou l'adresse d'une variable ou d'un tableau.

Pour fournir un résultat en quittant une fonction, nous disposons de la commande return:

La commande return L'instruction

         return <expression>;

- évaluation de l'<expression>
- conversion automatique du résultat de l'expression dans le type de la fonction
- renvoi du résultat
- terminaison de la fonction

Exemples

La fonction CARRE du type double calcule et fournit comme résultat le carré d'un réel fourni comme paramètre.

double CARRE(double X)
{
 return X*X;
}

Nous pouvons définir nous-mêmes une fonction TAN qui calcule la tangente d'un réel X à l'aide des fonctions sin et de cos de la bibliothèque <math>. En langage algorithmique cette fonction se présente comme suit:

fonction TAN(X): réel
|   donnée: réel X
|   si (cos(X) <> 0)
|   |   alors en TAN ranger sin(X)/cos(X)
|   |   sinon écrire "Erreur !"
|   fsi
ffonction (* fin TAN *)

En C, il faut d'abord inclure le fichier en-tête de la bibliothèque <math> pour pouvoir utiliser les fonctions prédéfinies sin et cos.

#include <math.h>

double TAN(double X)
{
 if (cos(X) != 0)
     return sin(X)/cos(X);
 else 
     printf("Erreur !\n");
}

Si nous supposons les déclarations suivantes,

   double X, COT;

printf("Le carre de %f est %f \n", X, CARRE(X));
printf("La tangente de %f est %f \n", X, TAN(X));
COT = 1/TAN(X);

void

En C, il n'existe pas de structure spéciale pour la définition de procédures comme en Pascal et en langage algorithmique. Nous pouvons cependant employer une fonction du type void partout où nous utiliserions une procédure en langage algorithmique ou en Pascal.

Exemple

La procédure LIGNE affiche L étoiles dans une ligne:

procédure LIGNE(L)
| donnée L
| (* Déclarations des variables locales *)
| entier I
| (* Traitements *)
| en I ranger 0
| tant que I<>L faire
| |     écrire "*"
| |     en I ranger I+1
| ftant (* I=L *)
| écrire (* passage à la ligne *)
fprocédure

Pour la traduction en C, nous utilisons une fonction du type void:

void LIGNE(int L)
{
 /* Déclarations des variables locales */
 int I;
 /* Traitements */
 for (I=0; I<L; I++)
      printf("*");
 printf("\n");
}

main

Dans nos exemples, la fonction main n'a pas de paramètres et est toujours du type int (Voir aussi Chap 2.2.2. Remarque avancée)
Typiquement, les programmes renvoient la valeur zéro comme code d'erreur s'ils se terminent avec succès. Des valeurs différentes de zéro indiquent un arrêt fautif ou anormal.

En MS-DOS, le code d'erreur retourné par un programme peut être contrôlé à l'aide de la commande IF ERRORLEVEL ...

Remarque avancée

Si nous quittons une fonction (d'un type différent de void) sans renvoyer de résultat à l'aide de return, la valeur transmise à la fonction appelante est indéfinie. Le résultat d'une telle action est imprévisible. Si une erreur fatale s'est produite à l'intérieur d'une fonction, il est conseillé d'interrompre l'exécution de tout le programme et de renvoyer un code erreur différent de zéro à l'environnement pour indiquer que le programme ne s'est pas terminé normalement.

Vu sous cet angle, il est dangereux de déclarer la fonction TAN comme nous l'avons fait plus haut: Le cas d'une division par zéro, est bien intercepté et reporté par un message d'erreur, mais l'exécution du programme continue 'normalement' avec des valeurs incorrectes.

exit

Pour remédier à ce dilemme, nous pouvons utiliser la fonction exit qui est définie dans la bibliothèque <stdlib>. exit nous permet d'interrompre l'exécution du programme en fournissant un code d'erreur à l'environnement. Pour pouvoir localiser l'erreur à l'intérieur du programme, il est avantageux d'afficher un message d'erreur qui indique la nature de l'erreur et la fonction dans laquelle elle s'est produite.

Une version plus solide de TAN se présenterait comme suit:

#include <math.h>

double TAN(double X)
{
 if (cos(X) != 0)
     return sin(X)/cos(X);
 else 
     {
      printf("\aFonction TAN:\n"
             "Erreur: Division par zéro !\n");
      exit(-1); /* Code erreur -1 */
     }
}

Ignorer le résultat

Lors de l'appel d'une fonction, l'utilisateur est libre d'accepter le résultat d'une fonction ou de l'ignorer.

Exemple

La fonction scanf renvoie le nombre de données correctement reçues comme résultat. En général, nous avons ignoré ce fait:

   int JOUR, MOIS, ANNEE;
   printf("Entrez la date actuelle : ");
   scanf("%d %d %d", &JOUR, &MOIS, &ANNEE);

   int JOUR, MOIS, ANNEE;
   int RES;   
   do
      {   
       printf("Entrez la date actuelle : ");
       RES = scanf("%d %d %d", &JOUR,&MOIS,&ANNEE);
      }
   while (RES != 3);