Sous-programmes : procédures et fonctions - 1

L'utilisation de sous-programmes vous permet d'éviter la duplication de code, au cas où vous auriez besoin d'écrire le même code à différents endroits du programme. 
Les bibliothèques importées dans un programme (par exemple, la bibliothèque mathématique math) sont constituées de sous-programmes qui ont déjà été compilés par quelqu'un. Les programmeurs n'ont pas besoin de réfléchir aux algorithmes qu'ils implémentent, mais simplement de les appliquer, en pensant uniquement à ce qu'ils font exactement. C'est un gain de temps considérable. Il n'est pas nécessaire d'écrire un algorithme qui a déjà été écrit par quelqu'un d'autre.

Chaque routine ne doit faire qu'une seule chose :  soit simplement calculer quelque chose, soit générer des données, soit faire autre chose. 

Il existe deux types de sous-programmes : les procédures et les fonctions

Les sous-programmes effectuent certaines actions, telles que l'affichage du résultat à l'écran sous une certaine forme (un exemple simple, l'instruction writeln() est un sous-programme standard qui imprime sur informations à l'écran)

Les sous-routines de fonctions retournent un résultat (nombre, chaîne de caractères, etc.) que nous pouvons utiliser dans le programme principal.

Essayons d'écrire une procédure simple :
Supposons que nous ayons besoin d'afficher la chaîne "Erreur" à l'écran chaque fois qu'une erreur peut se produire dans le code en raison de la faute de l'utilisateur (par exemple, lorsqu'il saisit des données incorrectes)
Cela peut être fait en écrivant l'opérateur writeln('Erreur'); Et maintenant, imaginez qu'une telle ligne doive être insérée à de nombreux endroits dans le programme. Bien sûr, vous pouvez simplement l'écrire partout. Mais cette solution a deux inconvénients.
1) cette chaîne sera stockée en mémoire plusieurs fois
2) si nous voulons changer la sortie en cas d'erreur, nous devrons changer cette ligne tout au long du programme, ce qui est plutôt gênant

Dans de tels cas, des procédures sont nécessaires.
Un programme avec une procédure pourrait ressembler à ceci : ... en utilisant l'espace de noms std ; procédure printError(); // description de la procédure commencer writeln('Erreur'); // corps de la procédure - commandes que la procédure exécutera fin; // programme principal commencer; ... erreur de l'imprimante(); // lance la procédure d'exécution. Nous spécifions simplement le nom de la procédure que nous voulons exécuter. ... erreur de l'imprimante(); ... fin. La procédure commence par le mot procédure. Après le nom de la procédure, des parenthèses sont écrites, qui indiquent les variables et leurs types dont dépend l'exécution de la procédure. Par exemple :

var a, b, réponse : entier ;
procédure Somme(a, b : entier);
commencer
    réponse := a + b;
fin ;

Toutes les instructions exécutées dans une procédure sont mises en retrait. 

Les procédures sont écrites avant le programme principal

Pour exécuter une procédure, dans le programme principal, vous devez l'appeler par son nom et n'oubliez pas d'écrire des parenthèses !
Vous pouvez appeler une procédure dans un programme autant de fois que vous le souhaitez.

Imaginons maintenant que nous ayons besoin d'afficher différents messages en réponse à l'erreur d'un utilisateur, selon le type d'erreur qu'il a commise.
Dans ce cas, vous pouvez écrire votre propre procédure pour chaque erreur :   procédure printErrorZero(); commencer writeln('Erreur. Division par zéro !'); fin; procédure printErrorInput(); commencer writeln('Erreur de saisie!'); fin; Et s'il y a beaucoup plus d'erreurs possibles ? Cette solution ne nous conviendra pas !
Nous devons apprendre à contrôler la procédure en lui indiquant quel message d'erreur afficher.
Pour cela, nous avons besoin de paramètres que nous écrirons entre parenthèses après le nom de la procédure procédure printError(s : chaîne); commencer écrire(s); fin; Dans cette procédure, s est un paramètre - une variable spéciale qui vous permet de contrôler la procédure.

Le paramètre est une variable qui détermine le fonctionnement de la sous-routine. Les noms des paramètres sont répertoriés séparés par des points-virgules dans l'en-tête du sous-programme. Après le paramètre, deux-points sont suivis de son type.

Maintenant, lors de l'appel de la procédure, vous devez indiquer entre parenthèses la valeur réelle qui sera affectée au paramètre (variable s) à l'intérieur de notre procédure printError('Erreur ! Division par zéro !'); Cette valeur s'appelle un argument.

L'argument est la valeur du paramètre qui est transmise à la sous-routine lorsqu'elle est appelée.

Un argument peut être non seulement une valeur constante, mais également une variable ou une expression arithmétique.

Il est souvent nécessaire d'utiliser des variables supplémentaires qui ne seront utilisées que dans le sous-programme. Ces variables sont appelées locales (ou locales) et ne peuvent être manipulées qu'au sein de la sous-routine dans laquelle elles sont créées.
 
Ainsi, il est possible de limiter la portée (portée) d'une variable uniquement au sous-programme où elle est vraiment nécessaire. En programmation, cette technique est appelée encapsulation  - empêcher une variable d'être modifiée de l'extérieur.

S'il est nécessaire de déclarer une variable qui serait visible n'importe où dans le programme (dans n'importe quel sous-programme), alors ces variables sont déclarées en dehors de tous les sous-programmes (voir le programme 3 du tableau ci-dessous)
Ces variables sont appelées globales.

Analysez trois programmes : s'affiche à l'écran

1) Dans ce programme, la variable i est locale. Une variable locale est déclarée dans une sous-routine	2) Ici, même s'il y a une variable i dans le programme principal (avec la valeur 7), une nouvelle variable locale i avec la valeur 5 sera créée.  Lorsque vous exécutez ce programme, l'écran affichera la valeur 75	3) Ce programme a une variable globale i. Sa valeur peut être changée à l'intérieur d'un sous-programme, et à l'intérieur du programme principal La procédure fonctionnera avec la variable globale i et lui attribuera une nouvelle valeur égale à 2. La valeur 2
test de procédure(); var i : entier ; commencer     je := 5;     écrireln(i); fin;	var i : entier ; procédure test(); var i : entier ; commencer     je := 5;     écrireln(i); fin ; commencer     je := 7;     écrire(i);     test(); fin.	var i : entier ; procédure test(); commencer     je := 2; fin ; commencer     test();     écrireln(i); fin.

Problème : écrire une procédure qui échange les valeurs de deux variables.
Les particularités de cette tâche sont que nous avons besoin que les modifications apportées à la procédure soient connues du programme appelant.

Essayons d'écrire la procédure comme ceci :

var x, y : entier ; procédure Swap(a, b : entier); // avec une telle description des paramètres de la procédure, var c : entier ; begin // va copier les valeurs des arguments (x et y) // les variables a et b sont des variables indépendantes non liées à x et y c := un; un := b; b := c; fin; commencer x := 1;   y := 2; Échange(x, y); //les valeurs des variables x et y (arguments) sont copiées dans les paramètres a et b writeln('x = ', x, ', y = ', y); //x=1, y=2 fin. Si vous exécutez ce programme, vous pouvez voir que les valeurs des variables x et y n'ont pas changé. Pour que les paramètres modifient les valeurs des arguments, vous devez utiliser passage de données par référence. Pour ce faire, après le nom du type de données dans l'en-tête du sous-programme, vous devez mettre le mot var  procédure Swap(var a, b : entier );   // maintenant les variables a et b obtiennent les adresses des variables x et y en mémoire var c : entier ;  commencer c := un; un := b; b := c; fin; Utilisation : Si vous passez un argument par référence, alors seul le nom de la variable (PAS un nombre et PAS une expression arithmétique) peut être à cet endroit lors de l'appel de la procédure !< br />
N'appelez PAS une procédure comme celle-ci : Échange(x, 4); Échange(5+x, y) ;