Procédures et fonctions

Parent Category: Informatique et réseaux Category: Programmation Pascal

Généralités

En Pascal lorsqu'un programme devient beaucoup plus complexe il est nécessaire d'utiliser une écriture modulaire permettant de scinder en plusieurs parties ou module le programme correspondant. Chaque module peut également être décomposé en module plus élémentaire, il existe deux sortes de module: les procédures et les fonctions.
Généralement une écriture modulaire permet:

  • D'éviter de recopier un segment de code plusieurs fois dans un même programme.
  • De décomposer un programme ou un module en petits modules, chacun effectuant un travail bien précis.
  • De constituer une bibliothèque de sous programme.

Définitions

Fonction: C'est une entité qui calcule un résultat unique en fonction d'un ou de plusieurs paramètres. La valeur calculée est mise à la disposition de l'utilisateur par l'intermédiaire du nom de la fonction, qui est une variable d'un type donné: celui de la valeur calculée.
Procédure: C'est une entité pouvant calculer et mettre à la disposition de l'utilisateur plusieurs valeurs ou aucune. Une procédure ou une fonction peut comporter toutes les parties d'un programme principal.


Déclaration

Les fonctions et les procédures sont déclarées juste après la déclaration des variables.

Déclaration d'une procédure

procedure nom([liste des paramètres]);
déclaration des variables locales;
Begin
corps de la procédure;
end;

Déclaration de la fonction

function nom([paramètres]): type;
déclaration des variables;
begin
corps de la fonction;
nom := valeur calculée;
end;

Exemple 1:

Ecrivons une procédure qui permet de lire un nombre strictement positif.
procedure Lecture(var a: real);
begin
write('Entrez un nombre positif');
repeat
read(a);
until a>0;
end;

Exemple 2:

Ecrivons une fonction booléenne qui est fausse lorsque le nombre est négatif, vraie lorsque le nombre est positif.
function Positif(b: real):boolean;
begin
if (b<0) then
Positif := false;
else
if (b>0) then
Positif := true;
else
write('Ce nombre est nul');
end;

Exemple 3:

Ecrivons un programme qui permet de lire deux nombres qui calcule et affiche la somme et la moyenne de ses nombres.
program calcul;
var nombre1, nombre2, S, M: real;

Procedure Lecture(var a, b: real);
begin
read(a);
read(b);
end;

function somme(x, y: real): real
begin
somme := x+y;
end;

function moyenne(i, j: real):real;
begin
moyenne := (i+j)/2;
end;

begin
write('Entrez deux nombres');
Lecture(nombre1, nombre2);
S := somme(nombre1, nombre2);
M := moyenne(nombre1, nombre2);
writeln('La somme est ', S);
write('La moyenne est ', M);
readln;
end.


Passage de paramètre

On distingue les effectifs et les paramètres formels:

  • Un paramètre formel est un paramètre utilisé dans la définition d'un sous-programme.
  • Un paramètre effectif ou réel ou actuel est un paramètre utilisé lors de l'appel d'un sous-programme, exemple: nombre1 et nombre2

Le paramètre actuel doit être compatible au paramètre formel correspondant (doit être de même type).
Un paramètre peut être:

  • Paramètre d'entré c'est-à-dire qu'il fournit les données au sous-programme, exemple: x, y
  • Paramètre de sortie c'est-à-dire qu'il contient le résultat à la fin du déroulement du sous-programme, exemple: a, b
  • Paramètre d'entrée sortie c'est-à-dire qu'il joue deux rôles: le rôle de paramètre d'entrée et le rôle de paramètre de sortie.

Les paramètres d'un sous-programme peuvent être transmis sous plusieurs formes. Les plus courant sont: la passage par valeur et le passage par adresse.

Passage par valeur

Il concerne les paramètres d'entrée. Lors du passage par valeur toute modification de la variable formelle n'affecte pas la variable actuelle correspondante.
Les paramètres transmis par valeur ne sont pas précédés par le mot var.

Le passage par adresse

Encore appelé passage par référence, il concerne les paramètres de sortie. Lors du passage par adresse, les paramètres sont des alias des paramètres actuels correspondants, c'est-à-dire qui partage le même emplacement mémoire.
Toute action effectuée sur le paramètre formel affecte le paramètre actuel correspondant.
Les paramètres transmis par adresse sont précédés par le mot var

Exercice 1:

program X

procedure A(i, j: integer);
begin
.
.
.
.
.
end;

procedure B(i, j: real);
begin
.
.
.
.
.
end;

Est-ce que ce program X est possible ou pas?

Exemple 1:

Ecrire un programme qui fait appel à une procédure pour permuter le contenu de deux variables. Les valeurs des deux variables à permuter sont lues par le programme principal.

program Exemple1

procedure Permuter(var a, b: real);
var c: real;
begin
c := a;
a := b;
b := c;
end;

begin
writeln('Entrez deux nombres');
write('X= '); readln(x);
write('Y= '); readln(y);
Permuter(x, y);
writeln('Le resultat est: ');
write('X= ', x);
write('Y= ', y);
end.

Exemple 2:

Ecrire un programme qui fait appel à une fonction pour déterminer la plus grande valeur entre deux variables.

program exemple2
var nbre1, nbre2, G: interger;
function plusgrand(x, y: interger): interger
begin
if (x>y) then
plusgrand := x;
else
plusgrand := y;
end;

begin
writeln('Entrez deux nopmbres');
read(nbre1);
read(nbre2);
G := plusgrand(nbre1, nbre2);
writeln(le plus grand est ', G);
end.


La portée des variables

On distingue en général deux types de variables: les variables locales et les variables globales.

  • La variable locale ou privée: Elle est déclarée immédiatement après l'en-tête de la procédure.
    Une variable locale peut être globale pour une autre procédure.

    Exemple:
    procedure A()
    var x, y: type
    procedure B()
    var i, j: type
    fin
    fin
  • La variable globale publique: Elle est déclarée après les étiquettes, les constantes, les types et avant toute déclaration des procédures.

    Exemple:
    program
    label
    const
    type
    var
    procedure

Chaque sous-programme ne connaît que ses variables locales et ses variables globales. Mais le programme principal connaît uniquement les variables globales.

Exemple:

program X
var z, t: type

procedure A()
var x, y: type

procedue B()
var i, j: type
fin

fin

fin