• Accueil
• TD 1: gnuplot, C, dichotomie
• TD 2: Euler (modifié) [pendule]
• TD 3: Euler implicite [pendule]
• TD 4: Runge-Kutta 4 [Bruxellateur]
• TD 5: EDP parabol [Chaleur]
• TD 6: EDP hyperbol [Tube à choc]
• TD 7: Equ linéaires [Polymère]
• TD 8: Nbres aléat., Monte-Carlo
• TD 9: Minimisation [points Lagrange]

• Documentation
• Unix
• C
  • Structure d'un programme
  • Compilation / execution
  • Variables et formats
  • Entrées / sorties
  • Conditions
  • Boucles
  • Fonctions
  • Mémoire, tableaux, pointeurs
  • Allocation dynamique
  • Fichiers
  • Exemples simples
  • Exemples approfondis
• C++
• Java
• Python
• Comparatif langages
• Gnuplot
• Méthodes num.

• Nouvelles
• Notes de cours
• Enseignants

Le langage C - fonctions

Lorsqu'on effectue la même suite d'opérations plusieurs fois dans un même programme, il est utile de créer une fonction spécifique qui effectue ces opérations et d'appeler cette fonction là où on en a besoin (dans le programme principal ou dans une autre fonction).

Déclaration des fonctions

Il est nécessaire de prévenir le compilateur de quelles fonctions on va avoir besoin (afin qu'il vérifie qu'on les utilise correctement). Il faut donc déclarer les fonctions que l'on va utiliser avant de les utiliser.

Pour les fonctions qui font partie d'une bibliothèque de fonctions, ou bien du langage C lui-même, il faut inclure le fichier en-tête (header, d'extension .h) qui contient les déclarations de fonctions avec la commande

#include <fonctions.h>

ou alors

#include "fonctions.h"

L'utilisation des "guillemets" à la place des <crochets> permet au compilateur d'aller chercher le fichier fonctions.h dans le répertoire courant (sinon il va les chercher dans une liste de répertoires bien définie où sont installés les fichiers de ce type).

Lorsqu'on veut écrire soi-même une fonction, il faut la déclarer avant de l'utiliser. Le moyen le plus simple est de déclarer les fonctions au début du fichier source. Cela est valable si on crée un petit nombre de fonctions (pour des raisons de lisibilité du programme). Sinon, il est d'usage de regrouper les corps des fonctions dans des fichiers .c spécifiques, et de créer un fichier .h (avec le même nom pour s'y retrouver) qui contient les déclarations de toutes ces fonctions. Le programme principal n'aura plus qu'à inclure les fichiers .h nécessaires et de préciser, lors de la compilation, qu'on veut lier les fichiers contenant les fonctions utilisées au programme principal. Dans ce qui suit, nous utiliserons la méthode simple, sauf mention contraire.

Comme on l'a vu lors de la présentation du programme principal, une fonction possède

• un nom
• un type de retour
• une liste d'arguments
• un bloc d'instruction (ce que fait la fonction)

Lors de la déclaration, on ne précise que les trois premiers, le bloc d'instructions est remplacé par un point-virgule. Le nom de la fonction suit les mêmes regles que celui des variables. Il est utile également de donner un nom qui soit explicite (pour la compréhension du programme). Le type de retour précise si la fonction renvoit une valeur et de quel type celle-ci sera. Si la fonction ne renvoit rien, alors on utilise le type void. Une fonction peut prendre plusieurs arguments. Ce sont des variables dont le type est défini lors de l'écriture du programme, mais dont la valeur n'est déterminée qu'au moment de l'appel de la fonction. Les différents arguments sont séparés par une virgule et l'ensemble est mis entre parenthèses. Prenons quelques exemples :

• on veut écrire une fonction qui calcule le carré d'un nombre réel. La fonction aura alors un argument de type réel (le nombre que l'on veut élever au carré), et retournera un réel (le résultat). Nous pouvons l'appeler carre (pas d'accents en C). La déclaration sera alors float carre (float) ;
• on veut écrire une fonction qui calcule le quotient de deux nombres réels. On aura cette fois deux arguments de type réel, et un type de retour réel: float produit (float, float) ;

Corps d'une fonction

On appelle corps d'une fonction le bloc d'instruction qui la compose. Celui-ci commence par la définition de la fonction (type de retour, nom et liste d'arguments) mais il faut cette fois donner un nom à chaque argument, qui opère alors comme une variable du type défini. Ecrivons le corps des exemples précédents:

float carre (float x)
{
    float y ;   /* variable qui contiendra le résultat a renvoyer */
    y = x*x ;   /* calcul du carre de la variable x    */
    return y ;  /* retour de la valeur de y        */
}

float produit (float x, float y)
{
    float z ;   /* variable qui contiendra le résultat a renvoyer */
    z = x*y ;   /* calcul du produit de x par y    */
    return z ;  /* retour de la valeur de z        */
}

Appel d'une fonction

Pour utiliser une fonction, on écrit simplement le nom de la fonction suivit entre parenthèse d'autant de variables que la fonction attend d'arguments, avec le bon type (dans le bon ordre). Si la fonction retourne une valeur, il faut prendre soin de l'utiliser, soit en la stockant dans un variable du bon type, soit en l'utilisant directement dans une opération.

int main (void)
{
    float x, y, z ;   /*  trois variables réelles  */
    x = carre (5.0) ; /*  x = 5*5 = 25.0   */
    y = 3.0*x ;       /*  y = 3*25 = 75.0  */
    z = x*produit (x, y) ;   /*  z = 25.0*(25.0*75.0) = 46875.0  */
    printf ("z = %f\n", z) ; /*  affichage de la valeur de z     */
    return 1 ;  /*  fin du programme  */
}

Il est important de retenir que lorsqu'on appelle une fonction avec des arguments, ce sont en réalité des copies de ces arguments qui sont passés à la fonction. Ceci a deux conséquences:

• il n'est pas possible de modifier la valeur d'une variable par appel à une fonction. Par exemple

  void doubler (float x)  /* fonction qui double la valeur de l'argument */
  {
      x = x*2.0 ;  /*  l'argument est doublé ici   */
      return ;     /*  on ne retourne rien (void)  */
  }
  
  int main (void)
  {
      float z ;  /*  variable reelle  */
      z = 5.0 ;
      doubler (z) ;  /*  on essaye de doubler z  */
      printf ("%f\n", z) ;  /*  z vaut toujours 5 !!!  */
      return 1 ;
  }
  

  Lorsqu'on appelle la fonction à la ligne doubler (z) ;, en réalité, ce qui est passé à la fonction doubler est une copie de la variable z (même type (réel), même contenu (5.0), mais différente). Ainsi, la fonction doubler agit sur la copie et non pas sur la variable z, qui n'est donc pas modifiée. Pour permettre de modifier la valeur d'une variable dans une fonction, il faut utiliser les pointeurs.
• Il faut faire attention de ne pas donner d'arguments de taille trop importante, sinon, lors de l'appel de la fonction, une copie est créée, ce qui utilise de la mémoire. Comme la mémoire utilisée est une partie limitée de la mémoire totale disponible (on appelle cette mémoire la pile ou stack en anglais), cela peut poser des problèmes pour de gros objets (erreur du type 'stack overflow' ou dépassement de pile).

Exemples

Affichez, compilez et executez les programmes suivants :

prog8.c : Fonctions utilisateur.

prog9.c : Modification d'arguments d'une fonction.