Consultez gratuitement nos différents cours

  • La fibre optique (Télécommunications)

    Généralités La transmission des informations par les ondes électromagnétiques est l'une des principales caractéristiques des systèmes de télécommunications. La lumière infrarouge et la lumière visible utilisée en transmission optique sont également des ondes électromagnétiques. Fondamentalement, il n'y a pas de différence entre la lumière, les ondes radio, les rayons X et les rayons gamma, leurs propriétés respectives dépendent de leurs différentes fréquences (longueurs d'onde). L'onde...

    Lire la suite : La fibre optique

  • Les montages électriques (Technologie)

    Simple allumage Fonction L'installation simple allumage commande une ou plusieurs lampes à partir d'un seul point. Cas d'une seule lampe Le vas et viens Dans une installation va et vient on peut commander une ou plusieurs lampes à partir de deux points.     Les raccordements   Les raccordements sont réalisés à l'aide des boîtes de dérivation ou boîte de connexion. On peut aussi utiliser des barrettes ou dominos donc le rôles principal est de relier les fils...

    Lire la suite : Les montages électriques

  • La tectonique des plaques (Géologie)

    Lorsqu'on observe une carte géologique présentant des séismes, des volcans et des déformations, on se rend compte que ces accidents découpent la lithosphère en plusieurs morceaux. Chaque morceau constitue une plaque lithosphérique. La tectonique est l'étude des déformations des terrains sous l'effet des forces internes après leur mise en place. La tectonique des plaques quant à elle est l'ensemble des mouvements qui animent les plaques lithosphériques Plaques lithosphériques Les plaques...

    Lire la suite : La tectonique des plaques

Procédures et fonctions

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