Module
(UNITÉ-module, unité) est une unité de programme compilée de manière autonome (séparément) qui contient des composants de la section de description (étiquettes, constantes, types, variables, procédures, fonctions), et peut également contenir des opérateurs de la partie d'initialisation.
Le module lui-même n'est pas un programme exécutable, mais est destiné à être utilisé par d'autres programmes et modules.
Structure des modules
Le module a la structure suivante :
UNITÉ<
nom du module >
INTERFACE
<
section d'interface >
MISE EN ŒUVRE
<
section de mise en œuvre >
COMMENCER
<
section d'initialisation >
FIN.
Titre du module consiste en un mot réservé Unité(module) et le nom du module.
Le nom du module est choisi selon des règles générales et doit correspondre au nom du fichier disque contenant le code source du module.
L'extension dans le nom du module (. pas
) n'est pas spécifié, il est défini par défaut.
Le nom du module est utilisé pour le lier au programme principal à l'aide d'une clause Les usages .
Offre Les usages M.B. placé après le titre du module ou après les mots
Interface Et Mise en œuvre .
Partie interface Interface(interface, articulation, connexion) et contient des références à d'autres modules et des déclarations (descriptions) d'objets globaux, c'est-à-dire des étiquettes, des constantes, des types, des variables et des en-têtes de procédures et de fonctions disponibles pour le programme principal et d'autres modules (c'est-à-dire visibles). de dehors).
Section de mise en œuvre – commence par un mot-clé Mise en œuvre(exécution) et contient une description des objets locaux au module, c'est-à-dire des étiquettes, des constantes, des types, des variables qui ne sont pas accessibles au programme principal et aux autres modules (c'est-à-dire non visibles de l'extérieur) et une description complète des procédures et des fonctions. Dans ce cas, dans l'en-tête des sous-programmes se trouve une liste de paramètres formels. omis, mais s'il est donné, il doit correspondre exactement à la description dans la partie interface.
Section d'initialisation
– entre parenthèses verbales DÉBUT FIN.
et contient des instructions qui seront exécutées avant que le contrôle ne soit transféré au programme principal. Cela pourrait être opérateurs d'initialisation de données (variables) Par exemple, les opérateurs d'affectation et de saisie, ainsi que les procédures de liaison et d'ouverture de fichiers. Section Opérateurs m.b. vide DÉBUT FIN ou tout simplement être absent FIN .
Il y a un point à la fin du module.
Compilation et utilisation de modules
La RAM du système a une structure de segments (un segment équivaut à 64 Ko = 65 535 octets). Code de programme m.b. pas plus d'un segment, le volume de données ne peut pas dépasser un segment (sauf si de la mémoire dynamique est utilisée) et un segment pour la pile. La taille de la pile est définie par la directive (M$<>). La taille minimale de la pile est de 1 Ko, la taille maximale par défaut d'un segment est de 16 Ko. Les valeurs des variables locales sont poussées sur la pile lors de l'appel d'un sous-programme et extraites de la pile lors de la sortie.
Le code du module est placé dans un segment séparé, car il est traduit indépendamment du programme principal et le nombre de modules utilisés par le programme dépend uniquement de l'OP disponible. Cela vous permet de créer de grands programmes.
Le compilateur crée le code du module avec le même nom, mais avec l'extension TPU
(unité turbo pascal).
Pour utiliser un module par le programme principal ou d'autres modules, son nom (sans extension) est placé dans la liste de phrases Les usages
Si le module est compact et souvent m.b. utilisé par les programmes d'application, il peut être placé dans la bibliothèque de modules standards TURBO.TPL (bibliothèque Turbo-Pasacal )
en utilisant l'utilitaire TPUMOVER.
Mais cela ne devrait être fait qu'en cas d'urgence car... la bibliothèque est chargée dans l'OP et réduit l'espace réservé au programme.
Lors de la compilation d'un fichier avec le texte source d'un module, un fichier du même nom apparaît avec l'extension TPU
et est placé dans le répertoire spécifié par l'option
OPTIONS/RÉPERTOIRES/RÉPERTOIRES D'UNITÉS
ou dans le répertoire courant si cette option n'est pas disponible.
Lors de la compilation du programme principal, les modules utilisés doivent être dans le répertoire spécifié par l'option
OPTIONS/REPERTOIRES/REPERTOIRES EXE & TPU
ou dans le répertoire courant si cette option est manquante
Pour obtenir EXE fichier de tâches en option
COMPILE/DESTINATION/DISQUE(MEMORI)
installer DISQUE
.
Il existe trois modes de compilation de modules :
- COMPILER
- CONSTRUIRE
- FAIRE
Les modes sont définis par menu COMPILER
1.Mode COMPILER(appelé Alt-F9
) . Dans ce cas, le programme est compilé et les modules utilisés doivent être compilés. pré-compilé et stocké dans les répertoires appropriés.
2.Mode CONSTRUIRE(appelé -
F9) . Dans ce cas, les modules précédemment compilés sont ignorés et les modules avec l'extension sont recherchés. pas
et sont recompilés.
3.Mode FAIRE(appelé F9) . Dans ce cas, seuls les modules dont le texte a été modifié sont recompilés.
Exemple 16.1.
Dans le fichier entrée.txt il existe trois tableaux de nombres réels
2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Évaluer la fonction
où Max_a, Max_b, Max_c, Sa, Sb, Sc, ka, kb, kc - l'élément maximum, la somme et le nombre d'éléments positifs des tableaux correspondants a, b et c.
Afficher le résultat dans un fichier dehors.
SMS
et sur l'écran.
Texte du module
Unité UNMAS ;
Interface
Const n = 10 ;
Tapez vec = tableau de réels ;
Var z:vec;
je:entier;
f1,f2:texte;
Procédure SK1(z:vec; num:byte; Var s:real; Var k:byte);
Fonction MAX(z:vec; num:byte):real;
Mise en œuvre
Procédure Vv(s:char; num:byte;Var z:vec);
Commencer
Writeln("Tableau ",s);
Pour i:=1 à num faire
Commencer
Lire(f1,z[i]); Écrivez(z[i]:4:1," ":3);
Fin;
Lire(f1); Écrire ;
Fin;
Procédure SK1(z:vec;num:byte; Var s:real; Var k:byte);
Commencer
s:=0; k:=0;
pour i:=1 à num faire si z[i]>0 alors
Commencer
s:=s+z[je];
k:=k+1
Fin;
Fin;
Fonction MAX(z:vec;num:byte):real;
Var m:réel;
Commencer
m:=z;
pour i:=1 à num faire si z[i]>m then m:=z[i];
MAXIMUM :=m
Fin;
Commencer
Attribuer(f1,"inp.txt"); Réinitialiser (f1);
Attribuer(f2,"out.txt"); Réécrire (f2)
Fin.
Texte du programme
Programme lr7_16 ;
Utilise CRT, UNMAS ;
Var
a,b,c:vec;
y,sa,sb,sc:réel ;
ka,kb,kc:octet;
Commencer
clrscr;
Vv("une",8,une);
Vv("b",9,b);
Vv("c",n,c);
SK1(une,8,sa,ka);
SK1(b,9,sb,kb);
SK1(c,n,sc,kc);
y:=(MAX(a,8)+MAX(b,9)+MAX(c,n))+(sa+sb+sc+ka+kb+kc);
Writeln("Résultat :":20);
Write("Tableau a: ");
Writeln("sa=",sa:5:1," ka=",ka);
Écrire("Tableau b: ");
Writeln("sb=",sb:5:1," kb=",kb);
Écrire("Tableau c: ");
Writeln("sc=",sc:5:1," kc=",kc);
Writeln(" ":10,"y=",y:10);
Lire ;
Writeln(f2,"ђҐ§г"мв в:");
Writeln(f2," ":10,"y=",y:10);
Fermer(f1);
Fermer (f2)
Fin.
Résultats du programme
Tableau un
-2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Tableau b
2.3 -4.3 2.1 2.5 -3.7 -5.6 4.6 3.5 -7.5
Tableau c
-2.1 4.3 -2.3 7.6 4.5 -8.9 5.7 -4.5 6.8 -5.8
Résultat:
Tableau a : sa= 17,6 ka=4
Tableau b : sb= 15,0 Ko=5
Tableau c : sc= 28,9 kc=5
y= 9.330E+01
Modules en Pascal par rapport à la partie principale du programme, ils ressemblent à des sous-programmes (procédures et fonctions). Mais par définition, ce sont des programmes indépendants dont les ressources peuvent être utilisées dans d’autres programmes. De plus, les modules sont décrits en dehors de l'application appelante, mais dans un fichier séparé, donc un module est un programme compilé séparément. Le fichier du module compilé (c'est exactement ce qu'il faut pour l'utiliser) aura l'extension fournie par l'environnement de programmation (par exemple, .tpu, .ppu, .pcu).
En règle générale, les modules sont créés pour garantir la compacité du code, dont les grands projets doivent se soucier. Il convient également de noter que l'utilisation de modules, dans un sens, supprime la limitation de la segmentation de la mémoire, puisque le code de chaque module est situé dans un segment distinct.
La structure du module ressemble à ceci :
Unité<имя модуля>;
Interface
<интерфейсная часть>
Mise en œuvre
<исполняемая часть>
Commencer
<инициализация>
Fin.
Nom de l'unité
Nom du module suivant le mot-clé Unité, doit correspondre au nom du fichier (sans .pas) dans lequel se trouve son code. De plus, en utilisant le nom, le module est connecté à un autre module ou au programme principal. Pour ce faire, vous devez spécifier un mot de service Les usages, et répertoriez la liste des plug-ins séparés par des virgules :
Les usages<список имен модулей>;
Partie interface
La partie interface décrit les en-têtes des objets auxquels d'autres modules et programmes auront accès. Ce sont des constantes, des types, des variables et des sous-programmes. Par exemple, voici à quoi pourrait ressembler la partie interface du module Recherche, contenant des algorithmes de recherche d'éléments dans un tableau.
|
1 |
Recherche d'unité ; |
Pour déclarer ce module, vous devez préciser son nom dans le programme :
Après quoi il sera possible d’utiliser tous les objets décrits dans la partie interface.
Mise en œuvre
Cette section commence par le mot Mise en œuvre(mise en œuvre). C'est ici que vous devez décrire les sous-programmes déclarés dans la partie interface. Dans le même temps, il est permis de ne pas indiquer de paramètres formels dans leurs en-têtes, sinon ils doivent coïncider complètement avec ceux de la partie interface. De plus, la partie interface peut contenir des objets locaux (inaccessibles au programme appelant) pour le module.
Partie initiatrice
La partie initiatrice commence son travail avant le début de l'exécution du programme principal. En règle générale, il (entre Begin et End) décrit les opérateurs destinés à divers types de travaux auxiliaires. Cette pièce peut être manquante ou ne contenir aucun code. Dans le premier cas, vous devez spécifier End avec un point, dans le second, laissez un espace vide à l'intérieur de Begin et End.
Compilation de modules
Vous ne pouvez utiliser dans le programme que des modules compilés possédant l'extension fournie par votre environnement de développement d'applications. Regardons les trois plus populaires d'entre eux :
TurboPascal
Le résultat de la compilation du module en Turbo Pascal sera un fichier avec l'extension .tpu (Unité Turbo Pascal), stockant son code.
Pascal gratuit
Après avoir compilé le module en Free Pascal, deux fichiers sont créés avec des résolutions différentes : .ppu Et .o. Le premier contient la partie interface du module, et le second (nécessaire à la composition du programme) contient une partie des implémentations.
Pascal ABC.NET
Pascal ABC.Net ne génère pas de code en langage machine lors de la compilation du module. Si la compilation réussit, le code est enregistré dans un fichier avec autorisation .pcu.
Il existe trois modes de compilation pour les environnements de programmation Turbo Pascal et Free Pascal : Compiler, créer et construire. En mode Compilation, tous les modules utilisés dans le programme doivent être compilés au préalable. L'application en mode compilation Make vérifie tous les modules connectés pour la présence de fichiers avec la résolution appropriée pour l'environnement de programmation (.tpu ou .o). Si l'un d'entre eux n'est pas trouvé, alors un fichier est recherché avec le nom du module introuvable et l'extension .pas. Le mode le plus fiable est Build. La recherche et la compilation de fichiers (avec l'extension .pas) dans ce mode se produisent même lorsque des fichiers modulaires existent déjà.
Exemple
Créons un petit module contenant des procédures de recherche binaire et linéaire d'éléments dans un tableau. Code du module :
|
1 |
Recherche d'unité ; |
Tout ce code doit être dans un fichier séparé. Écrivons maintenant le programme principal auquel nous allons connecter notre module de recherche.
Module ne représente pas un programme exécutable, mais contient uniquement un ensemble d'outils à utiliser dans un programme exécutable : types de données, variables, procédures et fonctions. Le texte source du module porte l'extension .pas. Le module est compilé séparément du programme principal ; le module compilé a l'extension .tpu (Turbo Pascal Unit). Le module compilé terminé peut être utilisé dans le programme principal à l'aide de la clause using, qui est écrite immédiatement après le nom du programme.
Turbo Pascal dispose de modules standards : DOS, CRT (tube à rayons cathodiques), imprimante, graphique, système et d'autres. Ils n'ont pas besoin d'être décrits, mais peuvent être immédiatement inclus dans le programme grâce à une clause d'utilisation. Le module Système est utilisé dans tous les programmes, une exception a donc été faite pour lui ; il n'a pas besoin d'être inclus dans la clause "uses", il sera inclus automatiquement. D'autres modules doivent être inclus dans une clause using si le programme utilise des ressources de module, telles que des procédures et des fonctions.
Structure des modules
Le module a la structure suivante :
Unité< имя >;
Interface
< интерфейсная часть >
Mise en œuvre
< исполняемая часть >
[Commencer< инициирующая часть > ]
Fin.
Ici:
Unité- mot de code (module anglais) ; titre du module de début ;
<имя>
- nom du module (identifiant correct) ;
Interface- un mot de code qui débute la partie interface du module ;
Mise en œuvre- mot de code (implémentation en anglais) ; démarre la partie exécutable ;
Commencer- un mot de code qui commence la partie initiatrice ;
(partie du module Début< инициирующая часть >facultatif);
Fin.- signe de fin de module.
Ainsi, un module se compose d'un en-tête et de trois composants, dont chacun peut être vide.
La partie interface s'ouvre avec un mot de code Interface. Cette partie contient les déclarations de tous les objets globaux du module (types, constantes, variables et sous-programmes) qui devraient devenir disponibles pour le programme principal et/ou d'autres modules.
A noter que toutes les constantes et variables déclarées dans la partie interface du module, ainsi que les objets globaux du programme principal, sont placés par le compilateur Turbo-Pascal dans un grand segment de données (longueur maximale du segment 65521 octets).
L'ordre dans lequel les différentes sections des publicités apparaissent ainsi que leur nombre peuvent être arbitraires.
Vous ne pouvez pas utiliser de description avancée dans la partie interface des modules.
Partie exécutable
La partie exécutable commence par un mot de code Mise en œuvre et contient les corps de procédures et fonctions déclarées dans la partie interface. Cette partie peut également déclarer des objets locaux au module : types auxiliaires, constantes, variables et blocs, ainsi que des labels s'ils sont utilisés dans la partie initiale. Les procédures et fonctions globales précédemment déclarées dans la partie interface doivent être décrites dans le même ordre dans lequel leurs en-têtes apparaissent dans la partie interface. La description d'un bloc global dans la partie exécutable doit être précédée d'un en-tête dans lequel il est permis d'omettre la liste des variables formelles (et le type de résultat de la fonction), puisqu'elles sont déjà décrites dans la partie interface.
Mais si l'en-tête du bloc est donné dans son intégralité, c'est-à-dire avec une liste de paramètres formels et une déclaration de résultat, il doit correspondre à l'en-tête déclaré dans le front-end.
Les variables et constantes locales, ainsi que tout le code de programme généré lors de la compilation du module, sont placés dans un segment de mémoire commun.
Compilation de modules
L'environnement Turbo Pascal comprend des outils qui contrôlent la façon dont les modules sont compilés et facilitent le développement de grands projets logiciels. En particulier, trois modes de compilation sont définis : Compile, Make et Build. Les modes diffèrent uniquement par la manière dont le module en cours de compilation ou le programme principal en cours de compilation est associé aux autres modules déclarés dans la clause Uses.
Lors de la compilation d'un module ou d'un programme principal en mode Compile, tous les modules mentionnés dans la clause Uses doivent être précompilés et les résultats de leur compilation doivent être placés dans des fichiers du même nom avec l'extension .TPU. Par exemple, si un programme (module) a une clause Uses Global, alors le fichier GLOBAL.TPU doit déjà se trouver sur le disque dans le répertoire déclaré par l'option Répertoires Unit. Un fichier avec l'extension .TPU (de l'anglais Turbo-Pascal Unit) est créé à la suite de la compilation du module.
En mode MAKE, le compilateur vérifie la présence de fichiers TPU pour chaque module déclaré. Si l'un des fichiers n'est pas trouvé, le système essaie de trouver un fichier du même nom avec l'extension .PAS, c'est-à-dire avec le code source du module et, si le fichier PAS est trouvé, commence à le compiler. De plus, dans ce cas, le système surveille les éventuelles modifications du code source de tout module utilisé. Si des modifications sont apportées au fichier PAS (code source du module), qu'il existe déjà ou non un fichier TPU correspondant dans le répertoire, le système le compile avant de compiler le programme principal.
De plus, si des modifications sont apportées à la partie interface d'un module, alors tous les autres modules qui y accèdent seront également recompilés. Le mode Make simplifie ainsi grandement le processus de développement de gros programmes avec de nombreux modules : le programmeur est libéré de la nécessité de surveiller la correspondance des fichiers TPU existants et de leur texte source, puisque le système le fait automatiquement.
En mode Build, les fichiers TPU existants sont ignorés et le système tente de trouver (et de compiler) le fichier PAS correspondant pour chaque module déclaré dans Uses. Après avoir compilé en mode Build, le programmeur peut être sûr que toutes les modifications qu'il a apportées dans l'un des modules sont prises en compte.
La connexion des modules au programme principal et leur éventuelle compilation s'effectue dans l'ordre de leur déclaration dans la clause Uses. Lors du passage au module suivant, le système recherche d'abord tous les modules auxquels il se réfère. Les liens des modules entre eux peuvent former une arborescence de toute complexité, mais la référence explicite ou indirecte d'un module à lui-même est interdite.
Question 6
Le module CRT est une bibliothèque de procédures et de descriptions qui étend les capacités de l'utilisateur lorsqu'il travaille avec du texte, l'écran de texte et le clavier. Examinons quelques-uns d'entre eux.
1). TextMode(mode: integer) - sélectionne les modes CRT en mode texte spécifiés :
2).TextBackground (color: byte) - Sélectionne la couleur d'arrière-plan.
Le paramètre color est une expression de type entier, par exemple :
- 0- noir
- 1-bleu
- 2-vert
- 3-bleu
3). ClrScr - Effacement de l'écran. Toutes les positions des caractères sont remplies d'espaces. Cela utilise la couleur d'arrière-plan actuelle spécifiée dans la procédure TextBackGround.
4). TextColor (color:byte) - Définit la couleur des caractères. (constantes pour définir la couleur)
5). Window(x1,y1,x2,y2) - Définit une fenêtre de texte à l'écran. Les paramètres x1,y1 sont les coordonnées du coin supérieur gauche de la fenêtre, les paramètres x2,y2 sont les coordonnées du coin inférieur droit. La taille minimale est d'une colonne par ligne. Maximum - X = 80, Y = 25. Si les coordonnées ne sont pas valides, l'appel à la procédure Window est ignoré. Par défaut, la fenêtre est configurée pour remplir tout l'écran.
6).GoToXY(x,y: byte) - Positionne le curseur. Le curseur se déplace vers la position à l'intérieur de la fenêtre actuelle, qui est spécifiée par les coordonnées x et y (x - spécifie la colonne, y - spécifie la ligne). Le coin supérieur gauche est spécifié par les coordonnées (1,1) exemple : Fenêtre (1,10,60,20); AllerÀXY(1,1); Cela amènera le curseur à se déplacer vers le point avec des coordonnées absolues (1,10).
7).WhereX et WhereY renvoient respectivement les coordonnées X et Y de la position actuelle du curseur par rapport à la fenêtre actuelle. Type de résultat Octet.
8).Delay(ms: word) - Effectue un retard pendant le nombre spécifié de millisecondes. Le paramètre msec spécifie le nombre de millisecondes à attendre. Mais cette procédure est approximative, donc le délai ne sera pas exactement égal au nombre de millisecondes spécifié.
9).READKey - Lit un caractère du clavier.
10).Sound - est une procédure qui allume le haut-parleur interne ; Description : Son (hertz : mot) ; où le paramètre "hertz" précise la fréquence du signal généré en hertz. Le son retentira jusqu'à ce qu'il soit désactivé en appelant la procédure NoSound ;
11).NoSound - Éteint le haut-parleur interne.
Exemple d'utilisation de Sound, Delay, NoSound
Son(220); (allumer le son)
Retard (300); (attendez 300 ms)
Pas de son; (couper le son)
Question 7
Module graphique
TP dispose d'une grande variété d'outils pour travailler avec un écran VGA standard.
L'adaptateur VGA a une résolution de 640x480 pixels (point (0,0) dans le coin supérieur gauche de l'écran), 16 couleurs.
Avant de commencer à travailler avec des graphiques, vous devez l'initialiser et, une fois terminé, le « fermer ». Toutes les procédures et fonctions graphiques se trouvent dans le module Graph, sa connexion est donc également nécessaire.
Structure générale du programme graphique :
Utilise crt, graphique ;
var Gd, Gm : Entier ;
commencer
D.ieu := Détecter ;
InitGraph(Gd, Gm, "c:\bp\bgi");
...
(Voici la construction de l'image)
...
Clé de lecture ;
FermerGraphique ;
fin.
Le chemin c:\bp\bgi spécifie l'emplacement du fichier egavga.bgi (pilote graphique). Ce chemin peut être différent sur différents ordinateurs. Si le fichier egavga.bgi est placé dans le répertoire contenant le programme, il n'est pas nécessaire de spécifier le chemin.
Procédures et fonctions graphiques de base :
Construire des figures
PutPixel(x,y,c)
- affiche un point sur l'écran avec les coordonnées (x,y) et la couleur c
Ligne(x1,y1,x2,y2)
- trace une ligne avec le début au point (x1,y1) et la fin au point (x2,y2)
Rectangle(x1,y1,x2,y2)
- dessine le contour d'un rectangle de diagonale (x1,y1) - (x2,y2)
Barre(x1,y1,x2,y2)
- dessine un rectangle rempli de diagonale (x1,y1) - (x2,y2)
Cercle(x,y,r)
- dessine un cercle de centre (x,y) et de rayon r
Ellipse (x, y, ba, ea, xr, an)
- dessine un arc d'ellipse avec le centre en (x,y), le rayon horizontal et vertical xr et yr, et l'angle de début et de fin ba et ea
FillEllipse (x, y, xr, an)
- dessine une ellipse remplie de centre en (x, y), de rayon horizontal et vertical xr et yr
Abdos en Pascal, renvoie la valeur absolue d'une variable. Le résultat renvoyé par la fonction Abs a le même que l'argument : le paramètre passé à la fonction. Ce paramètre peut être de n’importe quel type de données numérique.
Syntaxe de la fonction Abs pour les entiers :
fonction Abs(L : LongInt) : LongInt;
fonction Abs(I: Int64) : Int64;
La dernière option n'est possible que pour et , puisque le Pascal classique n'a pas le type de données Int64.
Syntaxe de la fonction Abs pour les nombres réels :
fonction Abs(D : ValReal) : ValReal;
ValRéal est le type de données réel avec la plus grande valeur disponible sur un système d'exploitation donné. En fait, il s'agit d'un alias (alias) de l'un des types Extended ou Double.
Et maintenant un exemple d'utilisation :
Absence du programme ; var x : entier = -100 ; y:entier; commencer y := Abs(x); //y = 100 WriteLn("Abs(-100) = ", y); //Sortie 100 ReadLn ; fin.
Ici, nous déclarons d'abord une variable avec une valeur initiale de -100 (un nombre négatif).
Et dans le programme nous utilisons la fonction Abs et par conséquent la variable y sera égale à 100 (un nombre positif).
Que calcule la fonction Abs ?
En général, Abs est l’abréviation de Absolute. Comme vous pouvez le deviner, ce mot est traduit par « absolu, pur, incontestable ».
Vous devez retenir de votre cours de mathématiques à l'école qu'un nombre absolu, c'est-à-dire la valeur absolue ou le module d'un nombre x, est un nombre non négatif dont la définition dépend du type de nombre x.
En mathématiques, le module d'un nombre x est noté comme suit : |x|.
Autrement dit, la fonction Abs renvoie dans tous les cas un nombre positif. Cette fonction est disponible dans presque tous les langages de programmation, car elle est utilisée assez souvent et fait partie des bases des mathématiques.
Ainsi, on peut dire que la fonction Abs(x) calcule le module du nombre x. Autrement dit, Abs(x) en Pascal est identique à |x| en mathématiques.
Et enfin, créons notre propre analogue d'une fonction qui renvoie le module d'un nombre. La fonction ressemblerait donc à ceci :
Fonction MesAbs(iNum : entier) : entier; commencer si iNum
Ici, nous transmettons un entier à la fonction, qui peut être négatif ou positif. Dans la fonction, nous vérifions la valeur de ce nombre. Si le nombre est négatif, alors on le multiplie par -1, et on obtient ainsi un nombre positif. Si le nombre est positif, alors nous ne faisons rien - nous renvoyons simplement le nombre reçu via le paramètre iNum.
Comme vous pouvez le constater, l’algorithme est assez simple.
Certes, notre fonction ne peut fonctionner qu'avec des nombres entiers. Mais ce sont des bagatelles...
Pascal utilise des bibliothèques de sous-programmes pour implémenter une technologie de programmation structurée à l'aide de modules. Textuellement, les bibliothèques sont regroupées en unités logicielles indépendantes appelées modules de langage Pascal. Des modules sont créés pour implémenter des bibliothèques de routines. En règle générale, les modules combinent des sous-programmes qui exécutent des tâches de la même classe.
Module est une unité logicielle indépendante qui se compile de manière autonome et possède une structure spécifique.
Le module a la structure suivante :
L'en-tête du module en langage Pascal est constitué du mot de service Unit suivi du nom du module. Il existe des exigences strictes concernant le nom du module et ce nom doit correspondre au nom du fichier disque avec l'extension .pas dans lequel se trouve le texte du module.
Unité MonType ; //fichier MonType.pas
Le nom du module est utilisé pour connecter le module aux programmes et autres modules. Les programmes et modules établissent une connexion avec le module requis dans la section Utilisations du programme ou du module. Les modules peuvent appeler d'autres modules pour leur travail ; si un module appelle un autre module, alors la section Utilisations doit suivre le mot de service INTERFACE.
La partie interface du langage Pascal commence par le mot réservé INTERFACE. Il sert à connecter le module avec le programme principal ou d'autres modules. La partie interface contient la déclaration de tous les objets globaux du module. Tout d'abord, les sous-programmes, ainsi que les types et variables globaux, sont déclarés. Si un objet est déclaré globalement, il peut être utilisé dans le programme et le module appelant sans déclaration spéciale.
Unité Masse de Wod;
INTERFACE
UTILISE MonType ;
[nom_type] : [type] ;
[list_global_variables] :[type] ;
Dans la partie interface, les sous-programmes sont déclarés par leurs en-têtes, qui contiennent le nom du sous-programme et une liste de paramètres formels.
La partie exécutable du langage Pascal commence par le mot de service IMPLEMENTATION et contient une description des sous-programmes déclarés dans la partie interface ; de plus, les objets locaux au module (variables, constantes) peuvent être déclarés dans la partie exécutable. La description d'un sous-programme dans la partie exécutable doit commencer par le titre du sous-programme, et la liste des paramètres formels est omise.
La partie de démarrage Pascal termine le module, et cette partie peut être manquante ou vide. Il n'est pas recommandé d'effectuer la partie initiale, car des situations de gel peuvent survenir. Il contient des instructions exécutables, définit les valeurs initiales des variables globales, ouvre les fichiers nécessaires et établit des connexions avec d'autres fichiers.
Compilation de modules en Pascal
Lorsque vous travaillez avec des modules, vous devez compiler les modules eux-mêmes et compiler les programmes qui utilisent les modules. Comme vous le savez, dans l'environnement Borland Pascal, il existe trois modes de compilation (Compile, Build, Make). Lors de la compilation du module lui-même, le mode Compile est généralement utilisé, bien que d'autres modes soient également possibles si le module utilise d'autres modules. Lors de la compilation d'un module, un programme exécutable n'est pas créé, mais un fichier spécial du module compilé avec l'extension .tpw est créé. Les fichiers des modules compilés sont placés dans des répertoires, généralement nommés Units (définis dans les paramètres d'environnement). Lors de la compilation de programmes contenant des modules, les trois modes de compilation peuvent être utilisés. La compilation dans différents modes diffère en durée et en fiabilité.
Mode Compiler- simple et rapide. Dans ce mode, le compilateur vérifie la présence de modules plug-in dans la section Uses et compile les programmes s'ils sont présents. Si un module est manquant, la compilation s'arrête et un message indiquant que le module est manquant s'affiche.
En mode Faire le compilateur vérifie la présence de plug-ins et si un module n'est pas trouvé, le compilateur recherche le texte du module avec l'extension .pas, compile le module puis compile le programme. De plus, le compilateur vérifie les dates de création des modules .tpw et .pas. S'il détecte que la date de création du fichier .pas est postérieure à celle du fichier .tpw, il conclut que des modifications ont été apportées au texte du module et recompile à nouveau les modules. Cela le rend plus fiable.
En mode Construire tous les fichiers .tpw sont ignorés, le compilateur recompilera tous les modules utilisés dans le programme principal et compilera le programme. C'est le mode le plus fiable, mais en même temps le plus long.