Correction des rendus TP N°3 en expliquant

Correction des rendus du TP N°3 en expliquant
les problèmes de compréhension de la procédure et de la
fonction
[email protected]
J’ai pris au hasard un échantillon représentatif des réponses,
je vais essayer de faire mes remarques sur les choses qui
n’ont pas été comprises.
Quelle est la différence entre une procédures et une fonction ?
-
Une procédure est un sous-programme qui ne renvoie pas de résultat. Il vaut mieux afficher
le résultat avant de quitter la procédure avec writeln. Par exemple :
Procedure psomme (a,b : integer) ;
Var z :integer ;
{z est une variable qui reçoit le résultat, elle est locale à la procédure, c’est-à-dire quand on quitte la
procédure sa valeur est perdue}
Begin
Z :=a+b ;
Writeln(‘La valeur de la somme est :’,z) ;
End ;
N.B. Quand on utilise var, ce n’est pas la même chose voire en bas les explications.
-
Une fonction renvoie toujours un résultat. En fait, une fonction c’est comme en math, pour
l’appeler on fait y=f(x,y), mais cela se fait dans l’appel, c’est-à-dire dans le programme
principal. Donc une fonction renvoie un résultat et le type du résultat doit être déclaré. Par
exemple :
Function Fsomme(a,b : integer) : integer ;{le type du résultat est en rouge}
Var z :integer ;
{z est une variable qui reçoit le résultat, elle est locale à la procédure, c’est-à-dire quand on quitte la
procédure sa valeur est perdue}
Begin
Z :=a+b ;
Fsomme :=z ;
{le nom de la fonction en rouge reçoit le résultat z}
{pas d’affichage du résultat, il sera fait dans le programme principal}
End ;
Comment se fait l’appel des procédures et fonctions ?
-
Je vais essayer de faire l’appel de la procédure et la fonction déjà définies plus haut dans le
programme principal, voici donc le programme principal qui contiendra le corps de chaque
sous-programme et le programme principal
Program
Var
exempleAppelsProcetFonc;
c,d,e : integer ;
{c, d et e sont des variables réservées au programme principal]
{il vaut mieux ne pas les utiliser dans la procédure et la fonction}
Procedure psomme (a,b : integer) ;
Var z :integer ;
{z est une variable qui reçoit le résultat, elle est locale à la procédure, c’est-à-dire quand on quitte la
procédure sa valeur est perdue}
Begin
z:=a+b ;
Writeln(‘La valeur de la somme est :’,z) ;
End ;
Function Fsomme(a,b : integer) : integer ;{le type du résultat est en rouge}
Var z :integer ;
{z est une variable qui reçoit le résultat, elle est locale à la procédure, c’est-à-dire quand on quitte la
procédure sa valeur est perdue}
Begin
z :=a+b ;
Fsomme :=z ;
{le nom de la fonction en rouge reçoit le résultat z}
{pas d’affichage du résultat, il sera fait dans le programme principal}
End ;
{Ici le programme principal qui fait l’appel}
Begin
Write(‘Donnez deux nombres :’) ;
Readln(c,d) ;
Psomme(c,d) ; //appel de la procédure, elle affichera toute seule
e :=fsomme(c,d) ; //appel de la fonction avec affectation
writleln ;
//ne pas oublier d’afficher le résultat de la fonction
writeln(‘La somme effectuée par la fonction est :’,e) ;
End.
C’est quoi une procédure ou fonction paramétrée ?
-
Je peux écrire la procédure psomme sans paramètres, mais il faut demander la saisie dans le
corps de la procédure (voire partie en rouge ci-dessous), ainsi ma procédure deviendra :
Procedure psommeSP;
Var z,a,b :integer ;
{z est une variable qui reçoit le résultat, elle est locale à la procédure, c’est-à-dire quand on quitte la
procédure sa valeur est perdue}
Begin
Write(‘Donnez deux nombres a et b :’) ;
Readln(a,b) ;
z:=a+b ;
Writeln(‘La valeur de la somme est :’,z) ;
End ;
Le concept de « Var » dans les paramètres ?
Si on souhaite que les modifications apportées dans la procédure soient reportées dans le
code appelant, il faut mettre le mot clé var dans le passage de paramètre. C'est alors la
référence à la variable (et non pas la valeur de cette variable) qui est passé en
paramètre. Par exemple :
procedure echange(var a,b:real) ;
var temp:real;
begin
temp:=a;
a:=b;
b:=temp;
end;
Ici on peut remarque que dans la procédure, il n y a pas de writeln donc pas d’affichage, pourtant le
changement s’effectue même quand on quitte la procédure. Cela veut dire que a et b vont vraiment
être échangés.
Vous pouvez tester cette procédure dans un programme principal avec var, il y aura échange et sans
var pas d’échange. Je vous conseille vraiment de la tester.
Maintenant on va faire la correction des exercices.
Exercice 1 :
Program calcul_puissance ;
Uses crt ;
Var a , b : integer ;
z:longint;
Procedure saisir(var
{ici var
Begin
Write('Donnez un
Write('Donnez un
End ;
x,y:integer) ;
c'est important car sinon x et y seront perdues}
nombre: ');readln(x) ;
exposant: ');readln(y) ;
Function puissance(x,n:integer):longint ;
Var i:integer; P:longint ;
{longint, c'est pour les entiers grands}
Begin
P:=1 ;
For i:=1 to n do P:=P*x;
Puissance:=P ; {résultats P affecté au nom de la fonction}
End ;
Begin
saisir(a,b) ;
z:=puissance(a,b) ; {Appel d’une fonction avec affectation}
Writeln('La puissance calculée est :',z:5) ;
End.
Exercice 2 :
Program Calcul_factorielle ;
Uses crt ;
Var a : integer ;
z:longint;
Procedure saisir(var n:integer) ;
{ici var c'est important car sinon n sera perdues}
Begin
Write('Donnez un nombre: ');readln(n) ;
End ;
Procedure afficher(f,n:integer) ;
Begin
Writeln('La factorielle de:', n, ' est égale à:', f );
End ;
Function factorielle(n:integer):longint ;
Var i:integer; F:longint ;
{longint, c'est pour les entiers grands}
Begin
F:=1 ;
For i:=1 to n do
F:=F*i;
factorielle:=F ; {résultats P affecté au nom de la fonction}
End ;
Begin
saisir(a) ;
z:=factorielle(a) ; {Appel d’une fonction avec affectation}
afficher(z,a);
End.
Exercice 3 :
Program Calcul_factorielle ;
Uses crt ;
Var a : integer ;
Procedure saisir(var n:integer) ;
{ici var c'est important car sinon n sera perdue}
Begin
Write('Donnez un nombre: ');readln(n) ;
End ;
Procedure PairImpair(n:integer);
Var i:integer;
Begin
if (n mod 2 =0) Then
writeln('le nombre ',n, ' est pair')
else
writeln('le nombre ',n, ' est impair');
End ;
Begin
saisir(a) ;
PairImpair(a) ; {Appel d’une procédure avec un seul paramètre}
End.
Exercice 4 :
L’exercice 4 sera repris dans le TP suivant.