Logiciel - QuickPascal - Procédures et fonctions

Procédures et fonctions

Les procédures et les fonctions vous permettent d'écrire des programmes Pascal bien organisés, dans lesquels des tâches discrètes sont effectuées dans des modules séparés et logiquement contenus. Une fois que vous avez compris les procédures et les fonctions, vous êtes sur la bonne voie pour devenir un véritable programmeur Pascal.

Cette page commence par discuter des procédures, étant plus simples et plus couramment utilisées que les fonctions. La discussion couvre de nombreux sujets, tels que le passage de paramètres, étant communs aux procédures et aux fonctions. La page se termine par une explication des fonctions, des procédures imbriquées et de la récursivité.

Aperçu

Les procédures et les fonctions vous permettent de programmer en utilisant une approche «diviser pour mieux régner». Au lieu d'essayer de résoudre tous les aspects d'un gros problème à la fois, vous le divisez en plusieurs petits problèmes et résolvez chacun séparément. Cette stratégie vous permet d'écrire des programmes clairs et fiables exécutant différentes tâches dans des modules distincts et logiquement contenus. En Pascal, ces modules sont appelés procédures ou fonctions.

Diviser un programme en modules basés sur des tâches offre plusieurs avantages :

Rend les programmes plus faciles à écrire et à lire. Tous les énoncés liés à une tâche sont regroupés au même endroit.
Empêche les effets secondaires inattendus car vous pouvez utiliser des variables privées ("locales") n'étant pas visibles pour le programme principal ou d'autres sections.
Élimine la répétition inutile de code pour les tâches fréquemment effectuées.
Simplifie le débogage. Une fois que vous avez débogué une procédure ou une fonction, vous pouvez l'utiliser en toute confiance dans de nombreuses situations différentes.

La distinction entre procédures et fonctions peut se résumer en quelques mots. Une procédure exécute une tâche spécifique ; une fonction exécute une tâche spécifique et renvoie également une valeur. Si vous êtes familier avec QuickBASIC, vous remarquerez de nombreuses similitudes dans Pascal. Une procédure Pascal ressemble à une procédure SUB de QuickBASIC, et une fonction Pascal ressemble à une procédure FUNCTION de QuickBASIC. Si vous connaissez le langage C, vous remarquerez qu'une fonction C combine les qualités des procédures et des fonctions Pascal ; une fonction C peut renvoyer une valeur ou ne rien renvoyer.

Procédures

Les procédures et les fonctions sont très similaires - si similaires, en fait, que tout ce qui est expliqué dans cette section s'applique aux fonctions aussi bien qu'aux procédures. Pour éviter de répéter l'expression «procédures et fonctions» à chaque phrase, cette section ne fait référence qu'aux procédures. Vous devez le lire en sachant que ces idées s'appliquent également aux fonctions. La section «Fonctions», explique en quoi les fonctions diffèrent des procédures.

Une «procédure» est un ensemble de déclarations et d'instructions exécutant une certaine tâche. Vous avez déjà vu quelques-unes des procédures standard QuickPascal, telles que Writeln, écrivant une ligne. Cette section explique les procédures utilisant plusieurs programmes. Le premier exemple, CENTER.PAS, contient une procédure centrant une ligne sur l'écran :



Program Center;

{ CENTER.PAS: Démontrer d'une procédure simple }

 
Uses

 Crt;

 

Var

 row:Byte;

 title:String;

 

Procedure center_line(message:String;line:Byte);Begin

 GotoXY(40-Length(message) div 2,Line);

 WriteLn(message);

End;

 
BEGIN

 row:=2;

 title ='Chaque ligne de texte est centrée.';

 ClrScr;

 center_line(title, row );

 center_line( '------- ', row+1 );

 center_line('QuickPascal!',row+2);

END.

Le programme CENTER.PAS affiche ces lignes à l'écran :

Chaque ligne de texte est centrée. ------- QuickPascal!

Le reste de cette section fait fréquemment référence à l'exemple CENTER.PAS.

Procédures d'appel

Le programme CENTER.PAS utilise une procédure nommée center_line pour centrer une ligne. Vous "appelez" ou exécutez une procédure en indiquant son nom et en fournissant tous les "paramètres" ou éléments de données dont elle pourrait avoir besoin. La procédure center_line s'attend à ce que vous fournissiez deux paramètres : un morceau de texte à afficher et la ligne d'écran sur laquelle l'afficher. Pour afficher le message :

Vite!

sur la deuxième ligne d'écran, vous appelleriez center_line avec cette instruction :



center_line('Vite!', 2);

Vous répertoriez les paramètres entre parenthèses après le nom de la procédure, en plaçant une virgule entre chaque paramètre. Ici, le premier paramètre est la chaîne de caractères "Vite!" et le second est le chiffre 2. Plus loin dans cette page, vous apprendrez comment une procédure gère les paramètres qu'elle reçoit.

Déclaration d'une procédures

Une «déclaration» de procédure contient le code complet de la procédure. Voici la déclaration de procédure pour center_line :



Procedure center_line(message:String;line:Byte);Begin

 GotoXY(40 - Length(message) div 2, line);

 Write(message);

End;

Une déclaration de procédure comporte deux parties, appelées «entête» et «corps». "Un entête de procédure se compose du mot clef PROCEDURE, suivi du nom de la procédure et d'une liste de ses paramètres entre parenthèses. Il se termine par un point-virgule. Voici le début de la procédure center_line :



Procedure center_line(message:String;line:Byte);

La liste des paramètres indique le nom et le type de chaque paramètre. Cet exemple indique que center_line nécessite deux paramètres, un pour chacun des types de données STRING et BYTE. Le premier paramètre est nommé message et le deuxième paramètre est nommé ligne.

Le corps de la procédure est un bloc d'instructions contenant les instructions exécutables de la procédure. Comme les autres blocs, le corps de la procédure est entouré de BEGIN et END et se termine par un point-virgule. Voici le corps de la procédure center_line :



BEGIN

 GotoXY(40-Length(message) div 2, line);

 Write(message);

END;

Le corps de la procédure center_line contient deux instructions, chacune appelant une procédure Pascal standard. Le premier appelle la procédure GotoXY et le second appelle Write.

Déclarations FORWARD

Le Pascal exige que vous déclariez une entité avant de l'utiliser. Avant d'utiliser une variable, par exemple, vous devez déclarer son nom et son type. La même règle s'applique à une procédure. Avant d'appeler une procédure, vous devez la déclarer comme expliqué dans la section précédente.

Dans des programmes simples, tels que CENTER.PAS, il est facile de satisfaire la règle "déclarer avant d'appeler". Placez simplement toutes vos déclarations de procédure avant le corps principal du programme. Dans CENTER.PAS, la déclaration de procédure center_line apparaît avant le programme principal.

Parfois, cependant, vous devrez peut-être appeler une procédure avant qu'elle n'ait été déclarée. Cela peut être fait en fournissant une "déclaration avant" de la procédure avant l'appel de procédure.

Une déclaration directe est identique à un entête de procédure, sauf qu'elle contient à la fois le mot clef FORWARD et un point-virgule après la liste de paramètres. Par exemple, l'entête de procédure center_line ressemble à ceci :



Procedure center_line(message:String; line:Byte);

et sa déclaration avant ressemble à ceci :



Procedure center_line(message:String;line:Byte);Forward;

La déclaration préalable doit figurer avant la première référence à la procédure. La plupart des programmeurs proposent des références au début ou très près du début du programme.

Déclaration des variables locales

En plus des instructions, le corps de la procédure peut contenir des déclarations de variables. Les variables déclarées dans une procédure sont dites «locales», c'est-à-dire qu'elles ne peuvent être vues qu'à l'intérieur de la procédure. Comme leur visibilité est limitée, les variables locales sont moins susceptibles d'être modifiées accidentellement que les variables globales.

Le programme LOCAL.PAS illustre les variables locales. Il vous invite à entrer un nombre, puis affiche la factorielle de ce nombre. (Une factorielle est le produit de tous les nombres entiers de 1 à un nombre. Par exemple, la factorielle de 4 est 24, le produit de 1 * 2 * 3 * 4) :




Program local_variables;

 { LOCAL.PAS: Démonstration local de variables. }

 
Var

 num:Byte;

 

Procedure factor(value:Byte);

Var

 factorial:Real;

 count:Byte;

Begin

 Factorial:=1.0;

 FOR count:=1 to value do factorial:=factorial*count;

 Write( 'Factoriel de ', value, ' est ' );

 Writeln( factorial );

END; { Procédure factor }

 
BEGIN { Corps du programme }

 Write('Saisissez un nombre inférieur à 34 : ' );

 Readln(num);

 Factor(num);

END.

Voici une sortie typique de LOCAL.PAS :

Saisissez un nombre inférieur à 34 : 5 Factoriel de 5 est 1.20000000000000E+0002

La procédure factorielle dans LOCAL.PAS apparaît ci-dessous. Il déclare deux variables locales nommées factorial et count :



Procedure factor(value:Byte);

Var

 factorial:Real;

 count:Byte;

Begin

 factorial:=1.0;

 For count:=1 to value do

 factorial:=factorial*count;

 Write('Factoriel de ', value,' est ');

 Writeln(factorial);

End; { procédure factor }

Remarquez où les variables locales sont déclarées : entre l'entête de la procédure et le mot clef BEGIN.

Portée variable

Contrairement aux variables globales, étant déclarées en dehors de toute procédure et sont donc visibles partout dans le programme, les variables locales sont déclarées à l'intérieur d'une procédure et sont cachées au reste du programme. Si vous faites référence à une variable locale en dehors de la "portée", ou de l'intervalle, où elle est visible, QuickPascal émet un message d'erreur suivant :

Error P0032: Unknown identifier

Le même message apparaît si vous vous référez à une variable n'ayant jamais été déclarée. Dans les deux cas, cela signifie que la variable n'est pas visible - et ne peut pas être utilisée - à l'endroit où la référence apparaît.

La possibilité de limiter la visibilité d'une variable facilite l'écriture de programmes fiables. Si une variable est locale, elle ne peut pas être modifiée accidentellement par une autre partie du programme. De tels effets secondaires aléatoires sont courants dans les anciens programmes BASIC interprétés, dans lesquels toutes les variables sont globales.

Passer des paramètres

La procédure Factor dans LOCAL.PAS a une autre variable locale n'ayant pas encore été mentionnée. En plus de la factorielle et du décompte, qu'elle déclare, la procédure utilise une troisième variable nommée value :



Procedure Factor(value:Byte);

Var

 factorial:Real;

 count:Byte;

BEGIN

 factorial:=1.0;

 For count:=1 to value do factorial:=factorial*count;

 Write('Factoriel de ', value,' est ' )

 Writeln(factorial);

END; { Procédure factor }

Le paramètre value, dans l'entête de la procédure, est "passé" lorsque vous appelez la procédure factor. Le paramètre vient d'un nombre que vous tapez sur le clavier. La procédure principale dans LOCAL.PAS entrepose votre entrée dans une variable nommée num :



Writeln('Saisissez un nombre inférieur à 34 : ' );

Readln(num);

Le programme principal passe la valeur de num comme paramètre lorsqu'il appelle la procédure Factor :



Factor(num);

Lorsque vous listez un paramètre dans l'entête de la procédure, il devient une variable locale dans la procédure. Ainsi, le responsable de la procédure Factor :



Procedure Factor(value:Byte);

crée une variable locale nommée value. Dans la procédure Factor, la valeur peut être traitée comme n'importe quelle autre variable locale.

Passage par valeur

Le type de paramètre passant dans LOCAL.PAS est appelé "passage par valeur" car la procédure reçoit la valeur de la variable d'origine, pas la variable elle-même. Le programme BYVALUE.PAS illustre cette idée, ayant des conséquences importantes pour la gestion des variables :



Program byvalue;

{ BYVALUE.PAS: Démonstration d'un passage par valeur. }

 
Var

 global_var:Integer;

 

Procedure proc(local_var:Integer);Begin

 Writeln('local_var = local_var);
 local_var:=333;

 Writeln('local_var = ' ,local_var);

End; { Procédure proc }

 
BEGIN { Corps du programme }

 global_var:=5;

 proc(global_var );

 Writeln('global_var '= global_var);

END.

Voici la sortie de BYVALUE.PAS :

local_var = 5 local_var = 333 global_var = 5

Le programme déclare une variable globale nommée global_var et attribue la valeur 5 à global_var. La procédure proc s'attend à ce que vous passiez un paramètre, qu'elle nomme local_var. La procédure affiche la valeur de local_var (initialement, 5), puis change sa valeur en 333 et l'affiche à nouveau. Après le retour du contrôle au programme principal, BYVALUE.PAS affiche la valeur de global_var, restant à 5.

La procédure proc modifie la valeur de local_var. Mais ce changement n'a aucun effet sur la variable d'origine, global_var, n'étant pas affectée par tout ce qui se passe dans proc. La même chose est vraie même si les deux variables ont le même nom (si vous les nommez toutes les deux my_val, par exemple).

Passer un paramètre par valeur crée une copie locale de la variable dans la procédure. Étant donné que la procédure ne reçoit qu'une copie locale, elle peut donner n'importe quel nom au paramètre et modifier sa valeur, sans affecter les variables extérieures à la procédure.

Passage par référence

Parfois, vous voudrez peut-être qu'une procédure modifie la valeur d'un paramètre. Par exemple, disons que vous avez besoin d'une procédure échangeant deux variables. Si vous passez les variables par valeur, leurs valeurs changent à l'intérieur de la procédure d'échange, mais restent inchangées dans le reste du programme. Vous avez besoin d'un moyen d'indiquer à la procédure de modifier les variables d'origine, et non ses copies locales.

Le Pascal propose une deuxième méthode de passage, appelée "passage par référence", pour de tels cas. Le programme BYREF.PAS illustre cette méthode :



Program byref;

 { BYREF.PAS: Démonstration de passage par référence. }

 

Var

 var1,var2:Integer;

 
Procedure swap_vars(Var var1:Integer;Var var2:Integer);

Var

 temp:Integer;

Begin

 temp:=var1;

 var1:=var2;

 var2:=temp;

End; { Procédure swap_vars }

 
BEGIN

 var1:=55;

 var2:=99;

 Writeln('var1 = ',var1,' var2 = ',var2);

 swap_vars(var1, var2);

 Writeln('var1 = ',var1,' var2 = ',var2);

END.

Voici la sortie de BYREF.PAS :

var1 = 55 var2 = 99 var1 = 99 var2 = 55

Le programme déclare deux variables globales nommées var1 et var2, en leur attribuant respectivement les valeurs 55 et 99. Il imprime leurs valeurs, appelle la procédure swap_vars, puis imprime à nouveau leurs valeurs. La sortie prouve que swap_vars modifie les variables d'origine.

La différence importante entre ce programme et l'exemple précédent apparaît dans l'entête de la procédure swap_vars :



Procedure swap_vars(Var var1:Integer; Var var2:Integer);

Notez le mot clef VAR devant chaque nom dans la liste des paramètres. Il indique à la procédure swap_vars de traiter le paramètre comme une variable (située ailleurs) plutôt que comme une valeur. Au lieu de créer une copie locale de la valeur transmise, la procédure agit sur la variable elle-même.

Il se trouve que l'entête de la procédure swap_vars utilise les mêmes noms pour ces paramètres (var1 et var2) dans sa liste de paramètres. Mais le résultat serait le même si swap_vars utilisait des noms différents. Étant donné que les paramètres sont déclarés avec VAR, leurs noms dans swap_vars sont des synonymes des variables d'origine.

Vous pouvez souligner ce point en apportant une simple modification à l'exemple précédent, BYVALUE.PAS. Chargez le programme et ajoutez VAR à l'entête de procédure proc :



Procedure proc(Var local_var:Integer);

Après avoir apporté cette modification, la procédure proc modifie la variable globale global_var, donnant cette sortie :

local_var = 5 local_var = 333 global_var = 333

Dans le programme BYVALUE.PAS d'origine, la variable globale global_var conservait la valeur 5 même si proc modifiait la valeur de local_var. Passer global_var par référence donne à proc la possibilité de modifier global_var.

Lorsque vous passez un argument par référence, vous devez passer une variable, pas une valeur. Autrement dit, le paramètre doit être un nom de variable :



swap_vars(global_l, global_2); { correcte }

n'est pas une constante :



swap_vars(55, 99); { erreur ! }

ou une expression :



swap_vars(5 * 11, 93 + 6); { erreur ! }

Il est préférable de passer des paramètres par référence uniquement lorsque vous souhaitez que la procédure modifie le paramètre. Le passage inutile par référence crée les mêmes problèmes que la surutilisation des variables globales.

Les fonctions

Une fonction est une procédure renvoyant une valeur. Comme la plupart des langages, Pascal possède de nombreuses fonctions standard, telles que Sqrt, renvoyant une racine carrée.

Vous pouvez considérer une fonction comme un type particulier de procédure. Tous les concepts expliqués dans la section précédente s'appliquent également aux fonctions. Plutôt que de réaffirmer tout ce que les procédures et les fonctions ont en commun, cette section explique les caractéristiques différenciant les fonctions des procédures.

Le programme FUNCT.PAS contient une fonction simple :



Program FUNCT;

{ FUNCT.PAS: Démonstration de simple fonction. }

 
Var

 num,expo,powr:Real;

 

FUNCTION power(base,exponent:Real):Real;Begin

 If(base > 0)Then Power:=Exp(exponent*Ln(base))

             Else Power:=-1.0;

End;

 
BEGIN

 Write('Entrer un nombre : ');

 Readln(num);

 Write('Entrer un exposent : ' );

 Readln(expo);

 powr:=Power(num,expo);

 Writeln(num, ' ^ ' , expo, ' = ',powr);

END.

Le programme FUNCT.PAS vous invite à entrer deux nombres, une base et un exposant. Ensuite, il appelle la fonction puissance pour élever la base à l'exposant. La sortie typique apparaît ci-dessous :

Entrer un nombre : 2 Entrer un exposent : 8 2.00000000000000E+0000 ^ 8.00000000000000E+0000 = 2.5 6000000000000E+0002

FUNCT.PAS élève 2 à la puissance 8, donnant un résultat de 256.

Appels de fonctions

Les appels de fonction sont identiques aux appels de procédure. Vous indiquez le nom de la fonction, en énumérant entre parenthèses tous les paramètres requis par la fonction. La seule différence réside dans l'endroit où l'appel peut apparaître. Un appel de procédure peut être autonome en tant qu'instruction, mais un appel de fonction, parce qu'il renvoie une valeur, doit apparaître dans une affectation ou une expression.

L'instruction suivante de FUNCT.PAS appelle la fonction de puissance, affectant sa valeur de retour à la variable powr :



powr:=power(num, expo);

Notez la similitude avec un appel de procédure. La fonction power prend deux paramètres, étant listés entre parenthèses après le nom de la fonction.

L'exemple précédent utilise l'appel de fonction dans une affectation. Les appels de fonction peuvent également apparaître dans les expressions :



dazzle:=12*surprise(730, 88)/2;

Ici, la fonction de surprise apparaît dans le cadre de l'expression à droite du symbole d'affectation.

Renvoyer des valeurs à partir de fonctions

Une fonction renvoie une valeur en attribuant la valeur à son propre nom. Dans la fonction power, par exemple, cette instruction force la fonction à renvoyer la valeur -1.0 :



power:=-1.0;

La valeur de retour doit correspondre au type déclaré dans l'en-tête de la fonction. Étant donné que la fonction de puissance renvoie une valeur de type Real, l'instruction ci-dessus utilise la valeur -1.0 (avec un point décimal).

Déclarer des fonctions

Les déclarations de fonction sont identiques aux déclarations de procédure sauf que vous substituez FUNCTION à PROCEDURE et déclarez le type de retour de la fonction après la liste de paramètres. Ci-dessous la tête de fonction de FUNCT.PAS :



Function power(base,exponent:Real):Real;

Après la liste de paramètres, séparés par deux-points, se trouve l'identificateur Real, indiquant que la fonction de puissance renvoie une valeur de type Real. Si power renvoyait une valeur entière, vous remplaceriez Real par Integer, et ainsi de suite.

Encore une fois, à l'exception des différences notées dans cette section, les fonctions sont identiques aux procédures. Ils peuvent gérer les paramètres et les variables locales exactement comme décrit dans la section précédente.

Procédures imbriquées

En plus des variables locales, une procédure peut déclarer d'autres procédures. Vous pouvez "cacher" une déclaration de procédure dans une autre. Comme une variable locale, la procédure masquée n'est visible que dans la procédure où elle est déclarée. Cette fonctionnalité, unique à Pascal, vous permet de limiter la visibilité d'une procédure (et des variables locales de cette procédure) de la même manière que vous limitez la visibilité des variables locales. L'imbrication s'applique à la fois aux procédures et aux fonctions.

Le programme HIDEPROC.PAS illustre l'imbrication de procédures :



Program hideproc;

{ HIDEPROC.PAS: Démonstration de procédure imbriqué. }

 
Var

 globl:Integer;

 

Procedure proc(p_parm:Integer);

Var

 p_locl:Integer;

 

 Procedure hidden(hidn_parm:Integer);

 Var

  hidn_locl:Integer;

 Begin

  Writeln('hidden peut voir: globl, p_parm, p_locl, hidn_parm, hidn_locl');

 End; { Procédure hidden }

 

Begin

 Writeln('Proc peut voir: globl, p_parm, p_locl');

 hidden(44); { Passage de paramètre caché }

End; { proc }

 
BEGIN { Corps du programme }

 Writeln('Corps du programme peut voir: globl');

 proc(99); { Passage de paramètre à proc }

END.

HIDEPROC.PAS produit cette sortie :

Corps du programme peut voir: globl Proc peut voir: globl, p_parm, p_locl hidden peut voir: globl, p_parm, p_locl, hidn_parm, hidn_locl

Le programme a deux procédures nommées proc et hidden. Étant donné que la déclaration de procédure masquée apparaît dans la déclaration proc, hidden n'est visible qu'à l'intérieur de proc.

La sortie du programme montre comment l'imbrication affecte la visibilité des variables. Au niveau le plus profond de HIDEPROC.PAS - à l'intérieur de hidden - toutes les variables du programme sont visibles. La procédure hidden peut voir ses propres variables locales, plus les variables locales de la procédure proc, plus toutes les variables globales. Au niveau suivant, à l'intérieur du processus, la visibilité est plus restreinte. La procédure proc peut voir ses propres variables locales et les variables globales, mais pas les variables locales à hidden. Le programme principal a la visibilité la plus restreinte. Il ne peut voir que les variables globales.

L'imbrication affecte également la visibilité d'une procédure elle-même. La procédure hidden ne peut être appelée qu'à partir de la procédure proc, où elle est déclarée. Si vous appelez hidden depuis le programme principal, le QuickPascal génère une erreur, comme il le ferait si le programme principal faisait référence à l'une des variables locales de proc.

Récursivité

La «récursivité» est la capacité d'une procédure ou d'une fonction à s'appeler elle-même. L'utilisation principale de la récursivité est la résolution de certains problèmes mathématiques nécessitant des opérations répétitives.

Le programme RECURSE.PAS démontre la récursivité. Il s'agit d'une révision du programme LOCAL.PAS ayant démontré les variables locales. Comme son prédécesseur, RECURSE.PAS calcule une factorielle. Mais au lieu d'une boucle, il utilise une fonction récursive nommée factor :



Program recurse;

{ RECURSE.PAS: Démonstration récursive. }

 
Uses

 Crt;

 

Var

 num:Byte;

 result:Real;

 

Function factor(value:Byte):Real;Begin

 If(value > 1)Then factor:=value*factor(value - 1)

              Else factor := 1.0;

End; { factor }

 
BEGIN

 Write('Saisissez un nombre inférieur à 34 : ');

 ReadIn(num);

 result:=factor(num);

 Write('Factoriel de ', num, ' est ');

 Writeln(result);

END.

La sortie de RECURSE.PAS et LOCAL.PAS est identique :

Saisissez un nombre inférieur à 34 : 5 Factoriel de 5 est 1.20000000000000E+0002

La seule différence entre les fonctions normales et les fonctions récursives est qu'une fonction récursive contient une instruction s'appelant elle-même. Voici l'instruction récursive dans RECURSE.PAS :



Factor:=value*factor(value-1)

L'expression à droite de l'opérateur d'affectation contient un appel à la fonction Factor. Le premier appel au facteur peut déclencher un deuxième appel, qui peut déclencher un troisième appel, et ainsi de suite.

L'instruction IF au début de la fonction Factor empêche la fonction de s'appeler sans fin. Chaque procédure et fonction récursive doit inclure un tel mécanisme de sortie.

La plupart des procédures et fonctions récursives exploitent le fait que chaque invocation d'une procédure ou d'une fonction crée un nouvel ensemble de variables locales. La récursivité peut être très efficace en termes de temps de programmation. Vous pourrez peut-être résoudre un problème mathématique complexe avec seulement quelques lignes de code. Mais les procédures profondément récursives peuvent également être inefficaces en termes de mémoire, consommant d'énormes quantités de mémoire pour entreposer les variables locales.

Dernière mise à jour : Dimanche, le 28 août 2022

Section courante

A propos

Section administrative du site

Procédures et fonctions

Aperçu

Procédures

Procédures d'appel

Déclaration d'une procédures

Déclarations FORWARD

Déclaration des variables locales

Portée variable

Passer des paramètres

Passage par valeur

Passage par référence

Les fonctions

Appels de fonctions

Renvoyer des valeurs à partir de fonctions

Déclarer des fonctions

Procédures imbriquées

Récursivité