Routine (informatique)

En programmation informatique, on retrouve les routines sous deux formes principales :

Une routine est effective seulement si elle renvoie au moins une valeur à la routine appelante ou (inclusif) si elle a un effet sur son environnement (lecture d'un capteur, écriture sur un actionneur, altération d'une variable globale, etc.).

Dans la plupart des langages de programmation, la déclaration (et par conséquent la définition) d'une routine comporte en général :

• un mot-clé (procedure, function, action, etc.) dans le cas d'une routine dans un langage distinguant clairement les diverses formes de routine ;
• l'identifiant de la routine (nom donné par le programmeur à la routine) ;
• la description des paramètres indiquant pour chacun (s'il y a des paramètres) :
  • l'identifiant (nom) du paramètre,
  • le type (explicite ou implicite) du paramètre (dans le cas d'une routine dans un langage typé).

Dans le cas d'une fonction, la déclaration de la routine comporte aussi :

• le type de la routine (dans le cas d'une fonction d'un langage typé), c'est-à-dire le type de sa valeur de retour.

int

Somme

 (

int

Parm1

,

int

Parm2

);

Dans le cas d'une fonction, la définition de la routine comporte aussi :

• un corps contenant le code réalisant l'op��ration dévolue à cette routine ;
• l'affectation, dans le corps de la routine, d'un résultat à la valeur de retour de la fonction.

int

Somme

 (

int

Parm1

,

int

Parm2

)

{
    return Var1 + Var2;     //   Affectation d'un résultat à la valeur de retour de la fonction.
}

Dans certains langages de programmation qui le permettent, ce qui est rare aujourd'hui (2016), on précise le mode d'échange associé à chaque paramètre :

• un paramètre en entrée permet à la routine de recevoir un argument, mais pas d'y écrire ;
• un paramètre en sortie permet à la routine d'écrire dans l'argument ;
• un paramètre à modifier permet à la routine de recevoir un argument et d'y écrire.

Tous ces éléments n'apparaissent pas forcément dans tous les langages de programmation.

La signature (profil) d'une routine, ou décoration de nom, permet au traducteur (compilateur, interpréteur, etc.) de vérifier que la routine est employée de façon cohérente avec sa déclaration. Elle permet aussi au lieur (éditeur de liens) d'établir le lien avec la routine correspondante.

La signature utilise habituellement :

• le type de la routine ;
• l'identifiant de la routine ;
• la liste des spécifications des paramètres.

Dans les langages de programmation d'autrefois (par exemple, en FORTRAN IV), la routine appelée travaillait directement sur les variables de la routine appelante. À l'inverse, dans la plupart des langages de programmation modernes, la routine appelante fait une copie des arguments et transmet uniquement cette valeur copiée à la routine appelée. On parle ainsi de passage de paramètres par valeur. Il est toujours possible de travailler sur des variables sans copie, si celles ci ont été déclarées « globales ». On parle alors de programmation par effet de bord.

Cependant, les routines demandent souvent l'adresse mémoire des variables de la routine appelante (arguments) plutôt que leurs valeurs^[1]. Ce mécanisme utilise un pointeur (ou une référence, en C++, Perl ou PHP). Normalement, par souci de modularité, une routine ne renvoie pas de valeur par modification des variables de la routine appelante (arguments). Par exemple, en Fortran, cela est formellement interdit par les spécifications du langage et détecté par les compilateurs. Une fonction peut renvoyer un seul résultat par sa valeur de retour. Ce résultat peut, entre autres, être :

• de grande taille, comme une chaîne de caractères en PL/I ou une structure en C ;
• une adresse en mémoire ;
• un simple code d'erreur (en) (par exemple 0 si l'opération s'est bien terminée).

Le corps de la routine comprend :

• la définition des variables locales à la routine, certaines de ces variables n'existant que le temps de son exécution ;
• la séquence des instructions à exécuter.

Soit à écrire trois nombres par ordre croissant, on aura par exemple :

int max ( int a, int b )
{
    return a > b ? a : b;
}

int main ( int argc, char *argv[] )
{
    //...
    printf ( "La valeur maximum est %i.\n", max(123,456) );
    //...
    return 0;
}

Tous les langages de programmation n'implémentent pas les deux formes de routines. Les langages qui implémentent les deux formes de routines réservent un mot-clef pour les distinguer lors de leur déclaration.

Avec certains langages de programmation, les deux concepts sont proches, la distinction ne se faisant que dans le fait de renvoyer ou non une valeur ou lorsqu'une procédure tient lieu de fonction avec des résultats multiples ou si une fonction réalise des opérations d'entrée/sortie.

Par contre, dans le cas de langages n'admettant, au côté des procédures, que des fonctions pures, les deux concepts sont très distinct.

Par exemple, en langage C/C++ ou en Lisp toutes les routines sont des fonctions ; c'est pourquoi la documentation du langage ne parle que de fonction. Par contre, afin d'avoir l'équivalent de la procédure et pour convertir facilement des programmes écrits dans des langages ayant des procédures, le langage C/C++ fournit le type void qui permet de déclarer une fonction qui ne renvoie rien, ce qui en fait une procédure.

En langage C/C++, la valeur de retour de certaines fonctions, telles que printf() (écriture sur le flux de sortie stdout) ou scanf() (lecture sur le flux d'entrée stdin), qui rend compte de leur exécution, est plus souvent négligée par la routine qui les utilise ; ces fonctions jouent alors essentiellement un rôle d'instruction, comme une procédure.

En Algol W, toute routine renvoie une valeur, qu'on peut utiliser ou non, ce qui ressemble à l'approche du langage C.

PL/I ne considère une procédure que comme une fonction dont le résultat n'est pas mémorisé, ce qui ressemble aussi à l'approche du langage C. Par contre, les langages comme Fortran, Algol 60, BASIC, Pascal, Modula 2 distinguent clairement les deux concepts en utilisant des mots-clefs.

int somme(int var1, int var2);

int somme(int var1, int var2)
{
    return var1 + var2;
}

void afficher(int var);

void afficher (int var)
{
    printf ("Valeur = %i\n", var) ;
    return;
}

• Cet article est partiellement ou en totalité issu de l'article intitulé « Fonction informatique » (voir la liste des auteurs).

• Cet article est partiellement ou en totalité issu de l'article intitulé « Procédure (informatique) » (voir la liste des auteurs).

• Sous-programme
• Fonction (mathématiques)
• Méthode (informatique)
• Module (programmation)
• Programmation fonctionnelle
• Fonction récursive
• Fonction réentrante

Wirth N., Algorithmes et structures de données, Eyrolles, 1980, trad. de Algorithms + Data Structures = Programs, 1976, Prentice-Hall Series in Automatic Computation.

•   Portail de la programmation informatique