Paramètres
des
procédures
Accueil

du site

Au menu :

Invariabilité des paramètres réels passés par valeur.

Passage de pointeurs sur des variables.

Passage de paramètres par référence.

Passage de paramètres par valeur
Invariabilité des paramètres réels


Programme de démonstration :

#include <stdio.h>

ProcedureEssai(double x, double y)
{
-printf("Dans la procédure, avant redéfinition : x = %6.2f y = 6.2f\n",x,y);

-x = 65.23; y = 75.65;
-printf("Dans la procédure, après redéfinition : x = %6.2f y = %6.2f\n",x,y);
}

int main()
{
-double x = 7.2; double y = 9.4;
-printf("Avant appel à la procédure...: x = %6.2f y = %6.2f\n",x,y);

-ProcedureEssai(x,y);

-printf("Après sortie de la procédure : x = %6.2f y = %6.2f\n",x,y);

-return 0;
}

Affichage

Avant appel de la procédure ..........: x = .7.20 y = .9.40
Dans la procédure, avant redéfinition : x = .7.20 y = .9.40
Dans la procédure, après redéfinition : x = 65.23 y = 75.65
Après sortie de la procédure ........ : x = .7.20 y = .9.40
Press any key to continue

Pour un néophyte, c'est paradoxal, en effet :

  • on fait passer les paramètres x=7.2 et y=9.4 à la procédure dite "ProcedureEssai"
  • apparemment, ces valeurs sont bien reçues dans la procédure, avant leur redéfinition
  • c'est notre droit de les redéfinir dans la procédure en x = 65.23 et y = 75.65, bien qu'ici, cela ne serve à rien d'autre qu'à notre démonstration.
  • après sortie de la procédure, dans le programme principal, les valeurs de x et y sont revenues aux mêmes valeurs qu'avant l'appel.

Conclusion :
vous avez beau faire varier, à l'intérieur d'unr procédure, les valeurs des paramètres passés par le programme appelant ; elles récupèreront les mêmes valeurs qu'elles avaient avant l'appel dès la sortie de la procédeure dans le programme appelant

Autrement dit ,
Une procédure appelée ne peut pas faire varier les valeurs des paramètres qu'on lui passe.

C'est un prinvipe intéressant pour la clarté du programme : si les procédures modifiaient les valeurs de paramètres passés on aurait du mal à savoir où en sont les valeurs des variables au cours du programme sans connaître par faitement ce qui se passe dans les procédures.

Or, une des règles d'or de la programmation moderne est de ne jamais avoir à connaître le codes des procédures une fois qu'elles sont crées et définitivement testées.

Dans certains cas, il est utile, voire même indispensable de modifier ces valeurs.
Il nous faut donc d'autres manières de procéder que nous allons voir tout de suite.

 

Passage de paramètres par pointeur


Programme de démonstration :
Si vous ne maitrisez pas bien les pointeurs voyez notre rubrique.

#include <stdio.h>

ProcedureEssai(double * a, double * b)
{
-printf("Dans la procédure, avant redéfinition : *a = %6.2f *b = 6.2f\n",*a,*b);

-*a = 65.23; *b = 75.65;
-printf("Dans la procédure, après redéfinition : *a = %6.2f *b = %6.2f\n",*a,*b);
}

int main()
{
-double x = 7.2; double y = 9.4;

-printf("Avant appel à la procédure...: x = %6.2f y = %6.2f\n",x,y);

-ProcedureEssai(&x,&y);
-// Notez que &x et &y sont des pointeurs sur x et y

-printf("Après sortie de la procédure : x = %6.2f y = %6.2f\n",x,y);

-return 0;
}

Affichage :

Avant appel de la procédure ..........: .x = .7.20 .y = .9.40
Dans la procédure, avant redéfinition : *a = .7.20 *b.= .9.40
Dans la procédure, après redéfinition : *a = 65.23 *b.= 75.65
Après sortie de la procédure ........ : .x = 65.20 .y = 75.40
Press any key to continue

Contrairement au passage des paramètres par valeur, la valeur des variables du programme appelant sont modifiées si l'on passe à une procédure des pointeurs sur ces variables et non pas les variables elles-mêmes.

Remarques :

Les pointeurs &x et &y eux-mêmes ne sont pas modifiés par la fonction appelée.
(ce qui confirme qu'une procédure ne modifie jamais les paramètres qu'on lui passe).
C'est de toute manière impossible dans cet exemple car les pointeurs &x et &y sont des constantes.

Mais, même si les pointeurs passés avaient été des pointeurs variables et que leurs valeurs aient été modifiées à l'intérieur de la procédure, les valeurs de ces pointeurs avant et après l'appel de la procédure auraient été les mêmes.

Autrement dit, les pointeurs eux mêmes sont passés par valeur donc pas modifiés par la fonction.

Ce sont les contenus des variables pointées par ces pointeurs qui peuvent être définitivement modifiées par les procédures.

 

Passage de paramètres par référence


Nous allons voir maintenant une méthode plus conforme au style de programmation moderne pour obtenir d'une procédure qu'elle transforme les valeurs des paramètres qu'on lui passe.

#include <stdio.h>

ProcedureEssai(double & a, double & b) // Bien remarquer le '&' de référencement
{
-printf("Dans la procédure, avant redéfinition : a = %6.2f b = 6.2f\n",a,b);

-a = 65.23; b = 75.65;
-printf("Dans la procédure, après redéfinition : a = %6.2f b = %6.2f\n",a,b);
}

int main()
{
-double x = 7.2; double y = 9.4;
-printf("Avant appel à la procédure...: x = %6.2f y = %6.2f\n",x,y);

-ProcedureEssai(x,y);
-printf("Après sortie de la procédure : x = %6.2f y = %6.2f\n",x,y);

-return 0;
}

Affichage :

Avant appel de la procédure ..........: x = .7.20 y = .9.40
Dans la procédure, avant redéfinition : a = .7.20 b.= .9.40
Dans la procédure, après redéfinition : a = 65.23 b.= 75.65
Après sortie de la procédure ........ : x = 65.20 y = 75.40
Press any key to continue

Les variables passés en paramètres ont bel et bien été modifiées.

Intérêt d'écrire des procédures avec passage de paramètres par référence

On peut se poser la question puisque, dans le cas où l'on souhaite que la ou les variables passées
en paramètres soient modifiées, il exite en effet une autre méthode : le passage de paramètres par pointeur.
vue plus haut sur cette page.

La méthode de passage par pointeur exige que la procédure soit écrite spécialement.
Elle diffère beaucoup de la procédure avec apassage par valeur.
Elle manipule le pointeur sur la variable au lieu de cette variable directement.
Pointeurs et variables pointées sont source de confusion chez les débutants.
On craint que ce souci ne détourne l'attention du programmeur et n'occasionne des erreurs.

Avec le passage par référence, pas de problème !
Le code de la procédure est identique au code d'une procédure à passage par valeur,
à une très petite exception près : la zone déclarative entre parenthèses de la procédure.

Par valeur
Par référence
procedure ( int a)
procedure (int & a)

Et, bien entendu, il faut savoir que le compilateur, face à un passage par référence,
effectuera les opérations suivantes :

Lors de l'appel à la procédure : il passera un pointeur sur la variable et non la variable elle-même
Dans le corps de la procédure : il remplacera de lui-même chaque occurrence de la variable par son pointeur.

En somme, le compilateur en fait un maximum à la place de programmeur.
Mais le programmeur doit au moins savoir qu'en écrivant sa procédure sous l'une ou l'autre des formes, la variable passée sera modifiée dans un cas et pas dans l'autre !

Passage par référence et compilateurs


Tous les compilateurs n'acceptent pas les procédures écrites pour ce type de passage.

Les compilateurs anciens, mais aussi les compilateurs de C écrits pour des usages où les additifs du langage C++ ne servent pas. C'est le cas de la programmation industrielle pour automatismes.

Certains constructeurs, Microsoft ™ par exemple, écrivent des compilateurs C++
qui acceptent les deux versions C et C++ des fichiers source.

Ils s'adaptent automatiquement à l'un ou à l'autre de ces langages
pourvu que vous leur fassiez savoir discrètement.

Pour leur faire savoir, adoptez pour extension de fichiers source :

Langage
Extension du fichier source
Exemple
C
c
monprog.c
C++
cpp
monprog.cpp

La suite : Structures
 Sommaire Langage C C++
Accueil

du site