Cours 5 : fonctions, procédures, passage des paramètres

Ce cours aborde les notions fondamentales des fonctions, procédures et du passage des paramètres en programmation. Il s'inscrit dans une introduction à la structuration du code pour favoriser la réutilisation et la clarté des programmes.

Fonctions et procédures : définitions et utilité

Les fonctions et procédures permettent de capitaliser sur du code déjà écrit en introduisant de nouvelles "commandes" ou "opérations" nommées. Une procédure est un bloc de code qui effectue une action sans retourner de résultat, tandis qu'une fonction retourne une valeur après exécution.

Ces deux structures facilitent la réutilisation du code sans avoir à le réécrire à chaque fois. Elles peuvent aussi recevoir des paramètres, c’est-à-dire des variables dont les valeurs sont choisies lors de l’appel, permettant ainsi de personnaliser leur comportement.

Déclaration et appel des procédures

Une procédure se compose de :

• La définition, qui précise le type des paramètres et la manière dont la procédure s’exécute.
• Un ou plusieurs appels, c’est-à-dire les utilisations de la procédure dans le programme.

Exemple sans paramètre :

procedure aide()
debut aide
  ecrire "Aide du programme Machin."
  ecrire " l’option -o permet de definir le fichier sortie"
  ecrire " l’option -h donne ce message"
fin aide

Cette procédure affiche un message d’aide et peut être appelée plusieurs fois dans un programme, par exemple en cas d’erreur.

Exemple avec paramètre :

procedure erreur(valeur s: chaine de caracteres)
debut erreur
  ecrire "Programme Machin: on a renconter l’erreur" s
fin erreur

Cette procédure affiche un message d’erreur personnalisé selon la chaîne de caractères passée en paramètre.

Déclaration et appel des fonctions

Une fonction se définit par :

• Le type des paramètres.
• Le type de la valeur retournée.
• La manière dont la valeur est calculée.

Elle peut être appelée avec zéro, un ou plusieurs paramètres (arguments).

Exemple sans paramètre :

fonction pi(): reel
debut pi
  retourner 3.1415926535897931
fin pi

Exemple avec paramètres :

fonction fmax(valeur a: reel, valeur b: reel) : reel
variables m : un reel
debut fmax
  si (a > b) alors
    m <- a
  sinon
    m <- b
  fin si
  retourner m
fin fmax

Cette fonction retourne le maximum de deux valeurs réelles. Par exemple, l’expression fmax(pi()*pi(), 10.0) vaut 10.

Paramètres : nature et passage

Les fonctions et procédures sont utiles surtout lorsqu’elles possèdent des paramètres. Lorsqu’une fonction ou procédure est définie avec des paramètres, elle doit être appelée avec un nombre d’arguments égal et du même type que ces paramètres.

Dans la déclaration :

fonction fmax(valeur a: reel, valeur b: reel) : reel

les paramètres a et b sont déclarés avec leur type. Le mot-clé valeur indique que le passage des paramètres se fait par valeur.

Le passage par valeur signifie que, lors de l’appel :

• Les valeurs des arguments sont calculées.
• Ces valeurs sont copiées dans les paramètres locaux de la fonction.
• Le corps de la fonction s’exécute en utilisant ces paramètres comme variables locales.
• Le résultat est retourné et utilisé dans l’expression appelante.

Les modifications apportées aux paramètres dans la fonction n’affectent pas les arguments d’origine.

Limites du passage par valeur et passage par référence

Le passage par valeur ne permet pas de modifier les variables passées en argument. Par exemple, une procédure d’échange des valeurs :

procedure echange(valeur a: entier, valeur b: entier)
variable t: un entier
debut echange
  t <- a
  a <- b
  b <- t
fin echange

n’échange pas réellement les valeurs des variables passées en argument car seules des copies sont modifiées.

Pour modifier les arguments, il faut utiliser le passage par référence :

procedure echange(reference a: entier, reference b: entier)
variable t: un entier
debut echange
  t <- a
  a <- b
  b <- t
fin echange

Dans ce cas, les paramètres a et b deviennent des alias des arguments réels, pointant vers les mêmes emplacements mémoire. Toute modification sur a ou b modifie donc directement les variables passées en argument.

Attention, seuls des arguments qui se comportent comme des variables (par exemple une variable simple ou une case d’un tableau) peuvent être passés par référence.

Résumé sur les modes de passage des paramètres

• Déclarer un paramètre avec valeur signifie que l’appel ne modifie pas les arguments.
• Déclarer un paramètre avec reference signifie que l’appel peut modifier les arguments.
• Il est possible de mélanger les deux modes dans une même fonction ou procédure.
• Les tableaux sont toujours passés par référence, même si le paramètre est déclaré valeur.

Exemple complet : tri par sélection

Le tri par sélection peut être écrit de manière claire en utilisant fonctions et procédures avec passage de paramètres par valeur et par référence.

Fonction de recherche du minimum à partir d’un indice :

fonction mintab(valeur i: un entier, reference a: tableau): entier
variable k: un entier
debut mintab
  pour k <- i+1 a N faire
    si (a[k] < a[i]) alors
      i <- k
    fin si
  fin pour
  retourner i
fin mintab

Programme de tri par sélection :

constante N=10
type tab = tableau de N entiers

procedure echange(reference a, reference b) ...
fonction mintab(valeur i: un entier, reference a: tableau): entier ...

programme triselection
variables a: tab
debut triselection
  lire a
  pour i <- 1 a N-1 faire
    echange(a[i], a[mintab(i, a)])
  fin pour
  ecrire a
fin triselection

Ce programme lit un tableau d’entiers, puis effectue un tri par sélection en échangeant les éléments au fur et à mesure, avant d’afficher le tableau trié.

Implémentation en C++

Voici une version du tri par sélection en C++ utilisant les références pour le passage des paramètres :

#include <iostream.h>

const int N=10;
typedef int tab[N];

void echange(int &a, int &b)
{
  int t;
  t = a; a = b; b = t;
}

int mintab(int i, tab &a)
{
  int k;
  for(k = i+1; k < N; k++) {
    if (a[k] < a[i]) {
      i = k;
    }
  }
  return i;
}

void lire(tab &a)
{
  int k;
  for (k = 0; k < N; k++) {
    cout << "a[" << k << "] ? " << endl;
    cin >> a[k];
  }
}

void ecrire(tab &a)
{
  int k;
  for (k = 0; k < N; k++) {
    cout << "a[" << k << "] = " << a[k] << endl;
  }
}

void main()
{
  tab a;
  int i;
  lire(a);
  for (i = 0; i < N-1; i++) {
    echange(a[i], a[mintab(i, a)]);
  }
  ecrire(a);
}

Points clés

• Une procédure effectue une action sans retourner de valeur, une fonction retourne une valeur.
• Les paramètres permettent de personnaliser le comportement des fonctions et procédures.
• Le passage par valeur crée une copie des arguments, les modifications dans la fonction ne changent pas les variables d’origine.
• Le passage par référence fait pointer les paramètres sur les variables d’origine, permettant leur modification.
• Les tableaux sont toujours passés par référence.
• Le tri par sélection illustre l’utilisation combinée de fonctions, procédures et passage par référence pour manipuler un tableau.