Les modules Pascal sont des exemples de programmes. Plugins - Pascal. Écrire vos propres modules

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, la description des modules se produit en dehors de l'application appelante, mais dans un fichier séparé, un module est donc un programme compilé séparément. Le fichier du module compilé (c'est exactement ce qui est nécessaire à l'utilisation) aura l'extension fournie par l'environnement de programmation (par exemple, .tpu, .ppu, .pcu).

Les modules sont généralement créés pour garder le code compact, ce qui est une préoccupation pour les grands projets. Il convient également de noter que l'utilisation de modules supprime en quelque sorte la restriction sur 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
<инициализация>
Finir.

Nom de l'unité

Nom du module suivant le mot-clé Unité, doit correspondre au nom du fichier (sans .pas), qui contient 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 listez les plugins séparés par des virgules :

Les usages<список имен модулей>;

Pièce d'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, cela peut ressembler à la partie interface du module de recherche, qui contient des algorithmes pour rechercher des éléments dans un tableau.

Pour déclarer ce module, vous devez spécifier son nom dans le programme :

Après cela, il deviendra possible d'utiliser tous les objets décrits dans la partie interface.

Mise en œuvre

Cette section commence par le mot Mise en œuvre(la mise en oeuvre). C'est ici qu'il faut décrire les sous-programmes déclarés dans la partie interface. Dans le même temps, il est permis de ne pas spécifier 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émarrage du programme principal. Il (entre le début et la fin), en règle générale, décrit les opérateurs destinés à divers types de travaux auxiliaires. Cette partie il peut être absent 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.

Modules de compilation

Vous ne pouvez utiliser dans le programme que des modules compilés ayant une extension fournie par votre environnement de développement d'applications. Jetons un coup d'œil aux trois plus populaires :

Turbo Pascal

Le résultat de la compilation du module en Turbo Pascal sera un fichier avec l'extension .tpu (Unité turbo pascal) qui stocke son code.

Pascal libre

Après avoir compilé le module dans l'environnement Free Pascal, deux fichiers sont créés avec des permissions différentes : .ppu et .o... Le premier contient la partie interface du module, et le second (nécessaire pour lier le 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 est réussie, le code est enregistré dans un fichier avec permission .pcu.

Il existe trois modes de compilation pour les environnements de programmation Turbo Pascal et Free Pascal : Compiler, créer et construire... En mode Compile, tous les modules utilisés dans le programme doivent être compilés à l'avance. Une application en mode Make-compilation vérifie tous les modules connectés pour la présence de fichiers avec l'autorisation appropriée pour l'environnement de programmation (.tpu ou .o). Si l'un d'eux n'est pas trouvé, alors un fichier est recherché avec le nom du module non trouvé et l'extension .pas. Le plus fiable des modes est Build. Rechercher et compiler des fichiers (avec l'extension .pas) dans ce mode se produit 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 :

Tout ce code doit être dans un fichier séparé. Nous allons maintenant écrire le programme principal dans lequel nous connecterons notre module de recherche.

Module (UNITÉ-module, unit) - une unité de programme compilée de manière autonome (séparément) qui contient les composants de la section de description (étiquettes, constantes, types, variables, procédures, fonctions), et peut également contenir les 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
< partie interface >
LA MISE EN OEUVRE
< partie mise en œuvre >
COMMENCER
< section d'initialisation >
FINIR.

En-tête de module comprend mot reservé 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.
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 phrase Les usages .
Offre Les usages m. placé après l'en-tête du module ou derrière les mots

Interface et Mise en œuvre .

Pièce d'interface Interface(interface, articulation, connexion) et contient l'accès à d'autres modules et 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 qui sont disponibles pour le programme principal et d'autres modules (c'est-à-dire, visible de l'extérieur).

Section 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 disponibles pour le programme principal et d'autres modules (c'est-à-dire, non visibles de l'extérieur) et une description complète des procédures et fonctions. En même temps, dans l'en-tête du sous-programme, la liste des paramètres formels peut être trouvée. omis, mais s'il est donné, il doit correspondre exactement à la description dans la partie interface.

Section d'initialisation - est mis entre parenthèses COMMENCER FIN.
et contient des instructions qui seront exécutées avant que le contrôle ne soit transféré au programme principal. C'est un M. instructions d'initialisation de données (variables) Par exemple, instructions d'affectation, instructions d'entrée, ainsi que procédures de liaison et d'ouverture de fichiers. Section des opérateurs m. vide COMMENCER FIN ou simplement être absent FINIR .
Un point est mis à la fin du module.

Compiler et utiliser des modules

La RAM système a une structure de segment (un segment est égal à 64 Ko = 65535 octets). Code de programme m. pas plus d'un segment, la quantité de données ne peut excéder un segment (si vous n'utilisez pas de mémoire dynamique) et un segment pour la pile. La taille de la pile est définie par la directive (M$<>). La taille de pile minimale est de 1 Ko, le segment maximal est de 16 Ko par défaut. Les valeurs des variables locales sont poussées sur la pile lorsque le sous-programme est appelé et lorsque le sous-programme est quitté, elles sont extraites de la pile.
Le code du module est placé dans un segment séparé, car il est diffusé de manière autonome depuis le programme principal, et le nombre de modules utilisés par le programme ne dépend que de l'OP disponible. Cela vous permet de créer de grands programmes.
Le compilateur génère 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 d'offre Les usages
Si le module est compact et souvent m. utilisé par les programmes d'application, puis il peut être placé dans la bibliothèque de modules standard TURBO.TPL (Turbo-Pasacal-bibliothèque ) en utilisant l'utilitaire TPUMOVER.
Mais cela ne devrait être fait qu'en cas d'absolue nécessité, car la bibliothèque est chargée dans l'OP et réduit l'espace pour le programme.
Lors de la compilation du fichier avec le code source du module, le 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É

ou dans le répertoire courant si cette option est manquante.
Lors de la compilation du programme principal, les modules utilisés doivent être utilisés. dans le répertoire spécifié par l'option
OPTIONS / RÉPERTOIRES / RÉPERTOIRES EXE & TPU

soit dans le répertoire courant si cette option est manquante
Recevoir EXE fichier de tâche en option

COMPILER / DESTINATION / DISQUE (MEMORI)
installer DISQUE .
Il existe trois modes de compilation de modules :
- COMPILER
- CONSTRUIRE
- FABRIQUER

Les modes sont définis par le menu COMPILER

1. Mode COMPILER(appelé Alt-F9 ). Dans ce cas, le programme est compilé et les modules utilisés doivent l'être. sont précompilés et stockés 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 pas et sont recompilés.
3. Modes FABRIQUER(appelé F9). Cela ne recompilera que les modules qui ont changé dans le texte.

Exemple 16.1.

Dans le fichier inp.txt il y a trois tableaux de nombres réels

2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6

Fonction de calcul

où Max_a, Max_b, Max_c, Sa, Sb, Sc, ka, kb, kc sont l'élément maximum, la somme et le nombre d'éléments positifs des tableaux correspondants a, b et c.
Sortir 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éel ;
Var z : vec ;
i : entier ;
f1, f2 : texte ;

Procédure SK1 (z : vec ; num : octet ; Var s : réel ; Var k : octet) ;
Fonction MAX (z : vec ; num : octet) : réel ;

Mise en œuvre
Procédure Vv (s : car ; num : octet ; Var z : vec) ;
Commencer
Writeln ("Tableau", s);
Pour i : = 1 à num do
Commencer
Lire (f1, z [i]); Ecrire (z [i] : 4 : 1, " : 3) ;
Finir;
Lireln (f1) ; Écrire ;
Finir;

Procédure SK1 (z : vec ; num : octet ; Var s : réel ; Var k : octet) ;
Commencer
s : = 0 ; k : = 0 ;
pour i : = 1 à num do si z [i]> 0 alors
Commencer
s : = s + z [i] ;
k : = k + 1
Finir;
Finir;
Fonction MAX (z : vec ; num : octet) : réel ;
Var m : réel ;
Commencer
m : = z ;
pour i : = 1 à num do si z [i]> m alors m : = z [i] ;
MAX : = m
Finir;

Commencer
Attribuer (f1, "inp.txt"); Réinitialiser (f1) ;
Attribuer (f2, "out.txt"); Réécrire (f2)
Finir.

Texte du programme

Programmer lr7_16 ;
Utilise CRT, UNMAS;
Var
a, b, c : vec ;
y, sa, sb, sc : réel ;
ka, kb, kc : octet ;
Commencer
clrscr;
Vv ("a", 8, a);
Vv ("b", 9, b);
Vv ("c", n, c);
SK1 (a, 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);
Ecrire ("Tableau a:");
Writeln ("sa =", sa: 5: 1, "ka =", ka);
Ecrire ("Tableau b:");
Writeln ("sb =", sb: 5: 1, "kb =", kb);
Ecrire ("Tableau c:");
Writeln ("sc =", sc: 5: 1, "kc =", kc);
Writeln ("": 10, "y =", y: 10);
Readln;
Writeln (f2, "ђҐ§г" мв в: ");
Writeln (f2, "": 10, "y =", y: 10);
Fermer (f1) ;
Fermer (f2)
Finir.

Résultats du programme

Tableau a
-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

Plugins.

1. Dispositions de base

2. Structure générale du plug-in

Unité<имя модуля>; Fin de la mise en œuvre de l'interface.

Structurellement, le plug-in peut être divisé en trois sections : 1) Section interface - interface (doit être déclarée, peut être vide) 2) Section Implémentation - implémentation (doit être déclarée, peut être vide) 3) Corps du module - début- finir. (peut être absent)

2.1. Rubrique interfaces.

Un exemple de section d'interface :

Interface (plugins) Utilise AnotherUnit ; (constantes) Const PI = 3,14159265 ; E = 2,71828182; (types de données personnalisés) Type TMyType = array [-3..7] of real; (variables) Var temp : TMyType ; (procédures et fonctions) Procedure Fill (var x: TMyType); Fonction Find (const x : TMyType ; const Value : real) : Boolean ; Mise en œuvre

2.2. Rubrique mise en œuvre.

Exemple 1 (rubriques sous forme abrégée) :

Unité DemoUnit ; Interface (prototype de procédure) Procédure Swap (var a, b : entier) ; Échange de procédure de mise en œuvre ; Var Temp : entier ; Début Temp : = a ; a : = b ; b : = température ; finir; finir.

Exemple 2 (rubriques au complet) :

Unité DemoUnit ; interface (prototype de fonction) Fonction GetMax (a, b : entier) : entier ; Implémentation Fonction GetMax (a, b : entier) : entier ; Début Si a> b alors GetMax : = a Sinon GetMax : = b; Finir; Finir.

2.3. Le corps du module.

Un exemple de module contenant un corps :

Unité DemoUnit ; Interface Const N = 50 ; Var Roots : tableau de réels ; La mise en œuvre utilise les mathématiques ; Var I : entier ; (corps du module) Begin For i: = 1 to N do Roots [i]: = sqrt (i); Finir.

Un exemple de module sans corps : (voir l'exemple de module pour les en-têtes en forme complète).

2.4. Sections supplémentaires dans la structure du module.

Les compilateurs Free Pascal, Pascal ABC, Pascal ABC.Net permettent, en plus de ce qui précède, deux autres sections : - une section d'initialisation - une section de finalisation. 2.4.1. Rubrique Initialisation. Section d'initialisation- une portée de plug-in, placée après la fin de la section Implémentations, commençant par le mot-clé d'initialisation et se terminant par la section de finalisation, le cas échéant, ou le mot-clé end avec un point. Le but est similaire au corps du module. 2.4.2. Rubrique de finalisation. Section de finalisation- une région de plug-in qui est placée à la fin de la section d'initialisation, le cas échéant, ou à la fin de la section d'implémentations, et se termine par le mot-clé end avec un point. Objectif principal: libération des ressources allouées au fonctionnement du module.

unité DemoUnit ; interface var a : tableau de ^ entier (tableau de pointeurs) implémentation (allocation mémoire et initialisation de la valeur) procédure AllocateArray ; var i : entier ; commencer pour i : = 1 à 20 commencer Nouveau (a [i]) ; un [i] ^ : = je ; finir; finir; (libération de mémoire) procédure DeallocateArray; var i : entier ; commencer pour i : = 1 à 20 faire Dispose (a [i]) ; finir; initialisation AllocateArray ; (initialisation - début du travail - allouer de la mémoire) finalisation DeallocateArray ; (finalisation - fin du travail - mémoire libre) fin.

3. Compilation de modules.

Chaque plug-in est compilé séparément et le résultat de la compilation dépend du compilateur utilisé.

3.1. Compilation en Turbo Pascal.

Le résultat de la compilation du plug-in dans Turbo Pascal est un fichier * .tpu (Turbo Pascal Compiled Unit), qui est une représentation machine des données et du code qui s'y trouvent.

3.2. Compilation en Free Pascal.

Le résultat de la compilation du plug-in dans Free Pascal est deux fichiers : * .ppu - un fichier contenant la partie interface du module, et un fichier * .o - un fichier objet contenant certaines des implémentations. De plus, cette dernière est nécessaire à la mise en page de l'application.

3.3. Compilation à Pascal ABC.Net.

Contrairement aux environnements listés ci-dessus, Pascal ABC.Net ne génère pas de code en langage machine lors de la compilation du module. Le compilateur de cet environnement termine son travail après avoir effectué une analyse sémantique, en sauvegardant l'arbre sémantique du module dans un fichier au format intermédiaire - * .pcu - qui, en première approximation, peut être considéré comme le résultat de la compilation avec les restrictions indiquées.

3.4. Accélération de la compilation des programmes.

Au stade de la construction de l'application, l'éditeur de liens construit le module exécutable, en prenant les modules objets en entrée. Ainsi, les plug-ins étant déjà compilés, la compilation des programmes les utilisant est accélérée, puisqu'ils ont déjà été traités. C'est vrai pour Turbo et Free Pascal. Cependant, dans Pascal ABC.Net, l'accélération de la compilation n'est obtenue que du fait qu'il n'y a pas besoin d'effectuer d'analyse syntaxique et sémantique. Sortir: les versions compilées des exécutables ne sont pas compatibles entre les différents compilateurs.

Code de la tâche : "Plug-ins"

Textuel

Liste des programmes

Unité u1 ; procédure d'interface PrintFirst; procédure PrintFirstSecond; la mise en œuvre utilise u2 ; (<--- Раньше было в Interface } procedure PrintFirst; begin writeln("Print first"); end; procedure PrintFirstSecond; begin writeln("Print first"); PrintSecond; end; end.

Abdos en Pascal, renvoie la valeur absolue d'une variable. Le résultat renvoyé par la fonction Abs est 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ériques.

La syntaxe de la fonction Abs pour les entiers est :

fonction Abs (L : LongInt) : LongInt ;

fonction Abs (I : Int64) : Int64 ;

La dernière option n'est possible que pour et, puisqu'il n'y a pas de type de données Int64 en Pascal classique.

La syntaxe de la fonction Abs pour les nombres réels est :

fonction Abs (D : ValReal) : ValReal ;

ValReal est le type de données réel avec la plus grande valeur disponible sur le 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 :

Programme absfunc; var x : entier = -100 ; y : entier ; commencer y : = Abs (x) ; // y = 100 WriteLn ("Abs (-100) =", y); // Affiche 100 ReadLn; finir.

Ici, nous déclarons d'abord une variable avec une valeur initiale de -100 (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).

Ce que la fonction Abs calcule

En général, Abs est l'abréviation de Absolute. Comme vous pouvez le deviner, ce mot est traduit par "absolu, pur, indubitable".

Vous devez vous rappeler du cours de mathématiques de 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é | x |.

C'est-à-dire que la fonction Abs renvoie de toute façon un nombre positif. Une telle fonction est disponible dans presque tous les langages de programmation, car elle est utilisée assez souvent et est incluse dans les 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 le même que | x | en mathématiques.

Et enfin, créons notre propre analogue d'une fonction qui renvoie le module d'un nombre. Ainsi, la fonction sera quelque chose comme ceci :

Fonction MyAbs (iNum : entier) : entier ; commencer si iNum

Ici, nous passons un entier à la fonction, qui peut être négatif ou positif. Dans la fonction, on vérifie la valeur de ce nombre. Si le nombre est négatif, alors nous le multiplions par -1, et obtenons ainsi un nombre positif. Si le nombre est positif, nous ne faisons rien - nous renvoyons simplement le nombre reçu via le paramètre iNum.

Comme vous pouvez le voir, l'algorithme est assez simple.

Certes, notre fonction ne peut fonctionner qu'avec des entiers. Mais ce sont des petites choses...