Écrire ses propres fonctions

Approfondir : Écrire ses propres fonctions

Une fonction regroupe un traitement nommé, reçoit des paramètres et peut renvoyer un résultat. Les fonctions personnelles permettent de découper un programme en morceaux que l’on comprend, teste et réutilise séparément. Elles ne doivent pas être confondues avec les fonctions prédéfinies de la bibliothèque.

Prototype, définition et appel

Un prototype annonce le nom, le type de retour et les types des paramètres, par exemple int maximum(int a, int b);. La définition fournit le corps. Un appel comme maximum(4,9) évalue les arguments puis exécute ce corps avec les paramètres correspondants. Déclarer le prototype avant main permet de placer la définition après main sans appeler une fonction inconnue.

Le passage par valeur

En C, chaque paramètre reçoit une copie de la valeur passée. Affecter un nouveau nombre au paramètre local n’affecte pas la variable de l’appelant. Une fonction qui doit fournir une valeur nouvelle peut la renvoyer avec return. Pour agir sur un objet de l’appelant, on transmet son adresse dans un pointeur ; cette technique sera détaillée dans le chapitre des pointeurs.

Une seule responsabilité

Une fonction de calcul devrait recevoir ses données plutôt que relire systématiquement le clavier. Cela permet de tester maximum(4,9) sans interaction et d’appeler le même calcul pour des données issues d’un fichier. Séparer les lectures, les calculs et les affichages rend les erreurs plus faciles à localiser. Les variables locales évitent de partager un état global sans nécessité.

Type de retour et chemins possibles

Une fonction qui renvoie int doit fournir une valeur du bon type sur chaque chemin qui aboutit normalement à l’appelant. Une fonction void n’a pas de résultat à utiliser dans une expression. return termine la fonction courante, pas forcément tout le programme : seul le retour depuis main termine ici le programme. Ne pas renvoyer l’adresse d’une variable locale automatique, qui n’existera plus après le retour.

Récursion et limites

Une fonction peut s’appeler elle-même, à condition d’avoir un cas d’arrêt et une progression vers ce cas. Chaque appel actif consomme des ressources ; une grande profondeur peut épuiser la pile. Pour une simple somme ou un parcours de tableau, une boucle est souvent plus directe. La récursion n’est pas nécessaire pour commencer à découper proprement les programmes.

Fonctions : maximum réutilisable

#include <stdio.h>
int maximum(int a, int b);
int main(void) {
    printf("Maximum = %d\n", maximum(4, 9));
    printf("Egalite = %d\n", maximum(6, 6));
    return 0;
}
int maximum(int a, int b) {
    if (a > b) { return a; }
    return b;
}

Sortie écran : essai 1

Deux appels indépendants du même calcul.

Maximum = 9
Egalite = 6

Fonctions : constater la copie d’un paramètre

#include <stdio.h>
void modifier(int valeur) {
    valeur = 99;
    printf("Dans la fonction = %d\n", valeur);
}
int main(void) {
    int n = 5;
    modifier(n);
    printf("Dans main = %d\n", n);
    return 0;
}

Sortie écran : essai 1

Modifier un paramètre ne modifie pas la variable d’origine.

Dans la fonction = 99
Dans main = 5

S’entraîner et vérifier

#include <stdio.h>
int minimum(int a, int b);
int main(void) {
    printf("Minimum = %d\n", minimum(4, 9));
    printf("Egalite = %d\n", minimum(6, 6));
    return 0;
}
int minimum(int a, int b) {
    if (a < b) { return a; }
    return b;
}

Minimum = 4
Egalite = 6

Pratiquer avec le TD/TP 1 corrigé · Tous les exercices C.

Repère de lecture : les codes proposés utilisent des constructions disponibles en C11. Les règles du langage et de sa bibliothèque sont consultables dans les projets publics du WG14 (C11) et du WG14 (C23). Les exemples n’utilisent pas les nouveautés propres à C23.