Pour d'autres significations, voir Paramètre (homonymie).

En programmation informatique, un paramètre est une donnée manipulée par une section de code (voir : sous-programme, fonction, méthode) et connue du code appelant cette section.

On distingue deux types de paramètres.

Un paramètre d'entrée est une donnée fournie par le code appelant au code appelé. Cette donnée peut être transmise de deux façons :

• passage par copie (aussi appelé par valeur) : le code appelé dispose d'une copie de la valeur qu'il peut modifier sans affecter l'information initiale dans le code appelant ;
• passage par adresse (aussi appelé par référence) : le code appelé dispose d'une information lui permettant d'accéder en mémoire à la valeur que le code appelant cherche à lui transmettre. Il peut alors modifier cette valeur là où elle se trouve ; le code appelant aura accès aux modifications faites sur la valeur. Dans ce cas, le paramètre peut aussi être utilisé comme un paramètre de sortie.

Un paramètre de sortie est une donnée fournie par le code appelé au code appelant. Dans certains langages de programmation, il n'est pas possible de définir de paramètres de sortie autrement qu'en utilisant un paramètre d'entrée par son adresse. D'autres langages de programmation (comme le Pascal) obligent le programmeur à spécifier explicitement si un paramètre est d'entrée, de sortie ou d'entrée-sortie.

Les paramètres sont désignés différemment selon leur emplacement dans le code source.

On parle aussi d'argument muet. Il s'agit de la variable utilisée dans le corps de la routine.

Il s'agit de la variable (ou valeur) fournie lors de l'appel du sous-programme. Certains langages, comme Perl 6, utilisent le terme paramètre pour paramètre formel et argument pour paramètre effectif.

Une variable dont le nom est un numéro. Par exemple, en programmation shell UNIX, le premier paramètre d'un script s'appelle $1, le deuxième $2 et ainsi de suite. En traitement par lots (batch), les fichiers fournis en paramètre sont aussi désignés par %1 (qu'il est préférable de noter entre guillemets).

L'expression paramètre positionnel peut qualifier un paramètre effectif qui est reconnu par sa position mais dont le nom de la variable associée reste celui du paramètre formel. En Perl 6, les paramètres formels positionnels finaux peuvent être déclarés comme optionnels.

Contrairement aux paramètres positionnels, les paramètres nommés impliquent que chaque paramètre formel correspondant comprenne non simplement la valeur, mais aussi le nom. L'Objective C dispose d'un mécanisme proche de celui des paramètres nommés. Il s'agit en fait d'un nom de fonction composite et le passage de paramètre est bien un passage positionnel.

Il se peut que les paramètres effectifs (positionnels ou nommés) soient trop nombreux. Dans la plupart des langages, ce serait une erreur. Certains langages fournissent des paramètres formels implicites pour ce trop plein.

En Perl 5, un tableau appelé @_ est utilisé. C'est même le seul mécanisme de réception de paramètres effectifs. En Perl 6, les variables de trop plein viennent en complément des paramètres positionnels et nommés @_ est le nom par défaut du tableau de trop plein et %_ le nom par défaut de la table associative de trop plein. L'existence de @_ fait que le système de passage de paramètres en Perl 6 est une extension du système de Perl 5. Notez aussi que le trop plein n'est pas une forme de gestion d'erreurs mais une partie intégrante de la richesse du mécanisme de paramètre de Perl 6.

D'autres langages, comme le C++, permettent d'indiquer des valeurs par défaut à attribuer aux paramètres formels lors de la déclaration des fonctions. Cela permet d'éviter de les réécrire s'ils sont équivalents à chaque fois. En C, on peut utiliser les macros pour abréger l'écriture.

Pour regrouper les paramètres, on peut aussi utiliser un tableau ou une structure.

On voudrait quelquefois que tout ou partie d'un tableau fasse partie des paramètres positionnels formels. C'est possible en Perl 6.

Le typage des paramètres formels, supporté ou requis par certains langages, permet selon le cas de vérifier, à la compilation ou à l'exécution, le type des paramètres effectifs, et de susciter une erreur ou une exception si un des paramètres effectifs n'est pas du type attendu.

On appelle signature la liste des types des paramètres formels d'une fonctions ou méthode. Plusieurs signatures peuvent être attachées au même nom de fonction ou de méthode. En d'autres termes, plusieurs fonctions ou méthodes peuvent avoir le même nom mais sont distinguées par les types de leurs paramètres formels. Les paramètres effectifs permettront de déterminer quel est la signature la plus proche selon une métrique qui dépend du langage utilisé. Ce mécanisme qui consiste à choisir la bonne fonction ou méthode selon la signature et les paramètres formels s'appelle le dispatch multiple.

Finalement, une méthode ou fonction peut être partiellement abstraite par l'utilisation d'un type générique pour l'un de ces arguments formels : on parle alors de généricité. Si le corps de la méthode ou fonction est défini, on parle de polymorphisme paramétré ou de polymorphisme par sous-typage.

Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue ! Comment faire ?

• Portail de la programmation informatique