Les paramètres se divisent en paramètres formels et paramètres effectifs
Paramètres formels
Le terme anglais est Formal Parameter, on l’appelle généralement paramètre formel.
Un paramètre formel est une variable locale particulière écrite entre parenthèses dans la déclaration de la méthode, il ne s’agit pas d’une variable définie à l’intérieur du corps de la méthode.
Les deux variables dans les parenthèses après le nom de la fonction ci-dessous sont des paramètres formels. Les personnes ayant étudié le langage C devraient être familières avec cette notion.
// x, y sont deux paramètres formels
public void PrintArea(int x, float y )
{
}
Langage du code : C# (cs)- Il dispose d’un type de données et d’un nom de variable, lisible et modifiable ;
- Défini hors du corps de la méthode, il est initialisé automatiquement avant l’exécution de la méthode (à l’exception des paramètres de sortie
out) ; - Les multiples paramètres sont séparés par une virgule, il n’y a pas de limite sur leur nombre ;
- Son utilisation au sein du corps de la méthode est identique à celle d’une variable locale ordinaire.
Autrement dit, le paramètre formel est une variable locale spéciale. Il sert à recevoir les valeurs transmises lors de l’appel de la fonction. Son affectation a donc lieu au moment de l’appel de fonction ; quand le flux d’exécution pénètre dans la fonction, le paramètre formel a déjà reçu sa valeur.
public void PrintArea( int x, float y )
{
float area = x * y; // x, y sont des paramètres formels, area est une variable locale ordinaire qui stocke le produit de x et y
Console.WriteLine($"Calcul surface : { x } * { y } = { area }");
}
Langage du code : C# (cs)Exemple exécutable
class Program
{
static void Main()
{
Program program = new Program();
program.PrintArea(10,6.5F);
}
public void PrintArea(int x, float y)
{
float area = x * y; // x, y sont des paramètres formels, area est une variable locale ordinaire qui stocke le produit de x et y
Console.WriteLine($"Calcul surface : {x} * {y} = {area}");
}
}Langage du code : C# (cs)Résultat de sortie
Calcul surface : 10 * 6.5 = 65
Lorsqu’on appelle la fonction, c’est comme si on initialisait x à 10 et y à 6,5
Le F après 6.5F indique qu’il s’agit d’un nombre à virgule flottante simple précision float. Sans ce suffixe F, le compilateur l’interprète comme un double et génère une erreur.
Le float simple précision et le double double précision n’occupent pas le même nombre de bits en mémoire, c’est pourquoi leur précision de stockage est différente.
La précision correspond au nombre maximal de décimales qu’un type de données peut conserver fidèlement. Au-delà de cette limite, les valeurs risquent d’être imprécises, ce qui dépend du nombre de bits alloués en mémoire.
x et y sont des paramètres formels. Au moment de l’appel
cela revient à initialiser deux variables locales avec ces valeurs.
int x = 10;
float y = 6.5F;Langage du code : C# (cs)Attention :
Le type, l’ordre et la forme des paramètres formels associés au nom de la méthode forment la signature de la méthode. On peut considérer la signature comme la carte d’identité d’une fonction. Nous étudierons les signatures plus tard : deux méthodes sont identiques si leurs signatures concordent, nous aborderons aussi la surcharge de fonctions.
Paramètres effectifs
Terme anglais : Actual Parameters (paramètres effectifs, aussi appelés arguments)
Lors de l’appel d’une méthode, les variables ou expressions utilisées pour attribuer une valeur aux paramètres formels sont appelées paramètres effectifs. Avant l’exécution de la méthode, les valeurs des paramètres effectifs initialisent les paramètres formels correspondants.
- Les paramètres effectifs s’écrivent entre parenthèses lors de l’appel de la méthode ;
- Règle de compatibilité des types : le type du paramètre effectif doit correspondre au paramètre formel associé, ou le compilateur doit accepter une conversion implicite de type ;
- Correspondance par position : l’association se fait séquentiellement par défaut (paramètres positionnels).
Par exemple, modifiez la fonction Main du code ci-dessus comme suit. Le premier paramètre de l’appel est la littérale 5, le second est la variable locale f.
Program program = new Program();
float f = 6.3F;
program.PrintArea(5,f);
// 5 est un paramètre effectif sous forme d’expression constante, f est un paramètre effectif variable
// Correspondance positionnelle : 5 → x, f → y
Langage du code : C# (cs)Lors de l’appel, les valeurs des paramètres effectifs sont copiées dans les paramètres formels à la position correspondante, puis le corps de la méthode s’exécute.
Paramètres positionnels
class Calculate
{
// Deux paramètres formels de type int
public int Sum(int x, int y)
{
return x + y;
}
// Deux paramètres formels de type float
public float Avg(float x, float y)
{
return (x + y) / 2.0F;
}
}
class Program
{
static void Main()
{
Calculate cal = new Calculate();
int num = 6;
// Sum : paramètre effectif int correspond au paramètre formel int
Console.WriteLine("Sum: {0} and {1} is {2}",
5, num, cal.Sum(5, num));
// Avg : paramètre effectif int converti implicitement en float
Console.WriteLine("Avg: {0} and {1} is {2}",
5, num, cal.Avg(5, num));
}
}
Langage du code : PHP (php)Résultat de sortie
Sum: 5 and 6 is 11
Avg: 5 and 6 is 5.5Langage du code : HTTP (http)C# supporte la conversion implicite d’un type étroit vers un type large (int → float). La conversion inverse float → int provoque une erreur de compilation et nécessite un cast explicite manuel.
num est une variable de type int. Quand elle est transmise en tant que paramètre effectif au paramètre formel float de la fonction Avg, le compilateur réalise automatiquement une conversion implicite int vers float sans erreur. Cela vient du fait que l’intervalle de valeurs de int est entièrement inclus dans celui de float.
C’est pourquoi transmettre un int à un float n’entraîne aucune perte de données. On peut comparer cela à placer une petite caisse dans une plus grande. L’inverse n’est pas possible : on ne peut pas mettre une grande caisse dans une petite.
Paramètres