Présentation Pascale. Fondamentaux de la programmation en Pascal. Calcul du logarithme népérien
PASCAL INTRODUCTION AU LANGAGE DE PROGRAMMATION 2006 STRUCTURE DU COURS Interface et principales définitions ; structure du programme ; afficher des informations textuelles ; la saisie au clavier; connexion et utilisation des modules du système ; travailler avec des types de données de base (entier, réel, chaîne, tableau, fichier) travailler avec des graphiques ; utilisation de sous-programmes (procédures et fonctions); l'utilisation de modules. 2 INTERFACE DE L'ENVIRONNEMENT PASCAL Le langage de programmation Turbo Pascal 7.0 est enfermé dans une coquille d'outil. Il comprend : un éditeur de texte multi-fenêtres ; lieur de programme ; débogueur de programme ; système d'aide; compilateur. 3 INTERFACE ENVIRONNEMENT PASCAL 4 Liste des fichiers ouverts : Alt + 0 Accès rapide aux fichiers ouverts : Alt +<№ окна> DÉFINITIONS DE BASE Un mot réservé est un mot spécial utilisé par un langage de programmation pour séparer les zones logiques d'un programme. Un opérateur est une commande de langage qui effectue une action (vérification d'une condition, organisation d'une boucle, etc.) Un identificateur est un nom librement choisi par un programmeur pour des éléments de programme. Le type de données est une caractéristique d'un identifiant qui définit l'ensemble des valeurs qu'il peut prendre (nombres entiers ou fractionnaires, chaînes de caractères, expressions logiques, etc.). 5 STRUCTURE GÉNÉRALE DU PROGRAMME Programme Nom_du_programme ; Utilise la section des plugins ; Section de description des étiquettes des étiquettes ; Section Const de la déclaration des constantes ; Section de type décrivant les types de données natifs ; section de déclaration de variable Var ; Début Le corps principal du programme ; finir. Code minimum : 6 SCREEN OUTPUT Pour afficher des informations à l'écran, les opérateurs suivants sont utilisés : Write ou Writeln. F9 - Compiler + Vérifier Ctrl+F9 - Exécuter F9 → Ctrl+F9 - Eviter les erreurs Afficher les résultats de l'exécution du programme 7 ECRAN Résultat des instructions : WRITE Instruction "vide" WRITELN ajoute une ligne vide WRITELN 8 EXERCICE Afficher des informations à l'écran comme indiqué ci-dessous Bonjour! Ravi de vous voir! appelez-moi ordinateur. Matériel utilisé : Instructions de sortie : Write, WriteLn Opérateur "vide" WriteLn ; insère une chaîne vide. 9 CONNEXION DE MODULES SUPPLÉMENTAIRES Des modules supplémentaires étendent les capacités de vos programmes en introduisant des opérateurs supplémentaires. Les modules sont connectés dans la section Utilisations. ProgrammeMon ; Utilise Module1, Module2 ; ________________________ ________________________ ________________________ ____________________________ MODULE 1 Ensemble de ressources 1 … MODULE N Modules : Ensemble de ressources propre au système N Effacement de l'écran de texte Attente d'une pression sur une touche Module connecté nommé CRT 10 SORTIE D'ÉCRAN ALÉATOIRE Aller à XY (X, Y : nombre entier) Où X, Y : familiarité coordonnées à l'écran. X peut prendre des valeurs de 1 à 80, et Y de 1 à 25. Par exemple : Program My_program ; (Connexion du module) Utilise Crt ; Commencer (Effacer l'écran) ClrScr ; (sortie de données) GotoXY(1, 1); écrire("▒"); GotoXY(80, 1); écrire("▒"); GotoXY(1, 25); écrire("▒"); GotoXY(80, 25); écrire("▒"); (délai d'écran) ReadKey ; finir. Le programme affiche le symbole "▒" (code 177) dans les coins de l'écran. 11 SORTIE EN COULEUR TextColor (Couleur); Spécifie la couleur des caractères. TextBackground(Couleur); Spécifie la couleur de la familiarité. ProgrammeMonProgramme ; Utilise crt ; Begin TextColor(Red); TextBackGround(Bleu); Ecrire("Dehors"); CouleurTexte(Blanc); Write("herbe, "); CouleurTexte(Vert); TextBackGround(Jaune); Write("sur l'herbe"); TextBackGround(Magenta); Ecrire("bois de chauffage. "); Fin. 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Couleurs Noir Bleu Vert Cyan Rouge Magenta Marron LightGray DarkGray LightBlue LightGreen LightCyan LightRed LightMagenta Jaune Blanc 12 – noir – bleu – vert – cyan – rouge – lilas - marron - gris clair - gris foncé - bleu - vert clair - cyan clair - rose - lilas clair - jaune - blanc VALEURS Opérations sur les données IDENTIFIANTS Le terme identifiant s'applique aux constantes, variables, fonctions, procédures, composants et autres définis par l'utilisateur. objets Caractères autorisés : lettres latines, chiffres, trait de soulignement Restrictions : ne doit pas commencer par un chiffre, mais peut commencer par un trait de soulignement Ne peut pas contenir plusieurs mots Ne peut correspondre à aucun des mots clés Les identifiants ne sont pas sensibles à la casse . Identifiants incorrects : Data My name 2Array Var ( ( ( (les caractères russes sont utilisés ) Il y a un espace ) Commence par un chiffre ) Correspond au mot-clé ) nombres, chaînes de caractères, expressions logiques, etc.). 16 TYPE DE DONNÉES INTEGER 17 Ensemble fini de valeurs possibles type byte shortint word integer long range 0..255 -128..127 0..65535 -32768..32767 -2147483648..2147483647 ! Hors plage entraîne une erreur ! taille DÉCLARATION DES VARIABLES Une variable est un identificateur capable de stocker une valeur (un nombre, une chaîne, etc.) et de la modifier pendant le fonctionnement du programme. Syntaxe : Var<имя переменной> : <тип переменной>; Programme nom_programme ; Utilise la section des plugins ; section de déclaration de variable Var ; Début Le corps principal du programme ; finir. Espace réservé en mémoire du calculateur pour 3 variables 18 VALORISATION DES VARIABLES Pour définir la valeur d'une variable, il faut utiliser l'opérateur d'affectation := Syntaxe de l'enregistrement :<Переменная> := <Значение>; La valeur 3 est entrée dans la variable (entier) nommée A 19 OPÉRATIONS SUR VARIABLES ENTIÈRES 20 Opérations arithmétiques : + - * / Opérations standard : div | mode | sqr Ne peut pas être utilisé avec des types entiers Une variable nommée S est définie sur la somme des valeurs stockées dans les variables X et Y La valeur stockée dans une variable nommée S s'affiche à l'écran EXERCICE 21 1. Écrivez un programme qui affiche le résultat de la multiplication des nombres 15 et 20 2. Ecrire un programme qui affiche la valeur de la fonction f 2 x 3 y , lorsque x=11, y=3 Matériel utilisé : Les variables sont déclarées dans la section Var Le type entier est appelé Integer La syntaxe pour affecter une valeur à une variable est :<Переменная> := <Значение> ; Un panneau est placé après chaque opérateur ; (sauf pour début et fin dernier) REAL DATA TYPE Ensemble de valeurs √ √ Type ordinal Type réel Compatibilité unidirectionnelle : Réel Entier Réel ! Hors gamme et non respect des règles de compatibilité entraîne une erreur ! 22 OPÉRATIONS AVEC VARIABLES RÉELLES 23 Opérations standard : pi | Carré | péché | Cos | abdos | exp | Ln Rond | Trunc (réel → entier) Par exemple (X, S – type Réel) : X:= pi/3; S:= Sin(X) * 100 ; Écrire(Round(S)); Le rapport des valeurs stockées dans les variables X et Y est entré dans une variable nommée S. La position du nombre et le nombre de caractères dans la partie fractionnaire du nombre E indique la puissance du nombre. 5.6E-5 = 5.6·10-5 CHAÎNE DE TYPE DE DONNÉES 24 Les chaînes sont un ensemble ordonné de caractères. Les chaînes sont entourées d'apostrophes. Les chaînes ne sont pas compatibles avec les types entiers et réels. Type Plage Chaîne 255 caractères (Opérateurs de chaîne de base) + (concaténation) Longueur (S) ; ( longueur de chaîne ) Par exemple : X:= 'Vasya'; Write('En votre nom', Length(X), 'lit.'); S = X ; X = S ; EXERCICE Écrivez un programme qui affiche le résultat de la division des nombres 12,89 et 0,22 avec seulement trois chiffres significatifs après la virgule, dans le format suivant : premier nombre divisé par le deuxième nombre = résultat Écrivez (X:1:3, ' razdelit na ' , y:1 :3, ' = ' z:1:3) Matériel utilisé : le type String est appelé String Les chaînes sont entourées de postrophes Les chaînes sont concaténées avec un signe + Dans l'instruction display, les différents types sont séparés par une virgule 25 KEYBOARD INPUT 26 Pour entrer des informations à partir du clavier, vous devez utiliser l'opérateur d'entrée : Read ou ReadLn. Syntaxe : Lecture (N1, N2, ... Nn) ; Où N1, N2, ... Nn sont des variables (entier, réel, chaîne) Dans la variable X, la valeur entrée au clavier est entrée. Après avoir entré la valeur, vous devez appuyer sur la touche Entrée. S'il y a plusieurs variables dans l'opérateur, ils sont entrés par un espace ou en appuyant sur une touche Entrer EXERCICE 27 1. Ecrire un programme de mini-calculatrice qui calcule la somme de deux nombres entrés au clavier. 2. Écrivez un programme qui vous demande votre nom et, après avoir écrit votre nom, affiche un message d'accueil. Par exemple, si vous avez entré le nom Vanya, le programme affichera la phrase : Hello, Vanya!!! Matériel utilisé : Instructions d'entrée : Read, ReadLn OPÉRATEURS OPÉRATEUR CONDITIONNEL 29 L'opérateur conditionnel implémente le « branchement », c'est-à-dire qu'il modifie l'ordre d'exécution des opérateurs en fonction de la vérité ou de la fausseté d'une condition. Vérification des conditions NON Action 1 J'irai à la plage Il pleut OUI Action 2 Je prendrai un parapluie Action 3 J'irai au cinéma VÉRIFICATION DES CONDITIONS Opérations de comparaison : > - plus<
- меньше
=
- равно
>= - supérieur ou égal<= - меньше или равно
<>- différent de 30 Opérations logiques : Non Et Ou - Non - Et - Ou Par exemple : Si Ma taille > Taille de Petya, Alors je suis plus grand que Petya Si (il pleut) Ou (il neige), Alors je resterai à Si non ((il pleut ) ET (vent)), alors je vais me promener Lors de l'utilisation d'opérations logiques, les conditions sont mises entre parenthèses SYNTAXE DE L'OPÉRATEUR CONDITIONNEL Forme abrégée : Si<условие>ensuite<оператор>; Par exemple, si la valeur de la variable X est inférieure à 0, alors la valeur 1 est écrite dans la même variable : Si X<0 Then X:= 1;
Полная форма:
If <условие>ensuite<оператор_1>autre<оператор_2>; Par exemple : Si X>5 Alors X := X - 1 Sinon X := X + 1 ; Un seul opérateur peut être utilisé après les mots Then et Else Avant le mot Else, signe ; missing 31 EXERCICE 32 1. Ecrire un programme qui reçoit un montant d'entrée en dollars et un montant en euros, puis affiche dans quelle devise le montant est le plus élevé (1 dollar = 28 roubles, 1 euro = 35 roubles) 2. Ecrire un programme , qui prend trois nombres en entrée, puis affiche le maximum d'entre eux. Matériel utilisé : Formes de l'opérateur conditionnel : Si<условие>Puis<оператор>; Si<условие>Puis<оператор_1>Autre<оператор_2>; Signe Avant Sinon ; non défini Opérations de comparaison : >< = <> >= <=
Логические операции: Not Or And
ОПЕРАТОРНЫЕ СКОБКИ
Если после слов Then или Else необходимо записать несколько операторов, то их заключают в операторные
скобки (составной оператор).
Операторные скобки начинаются словом Begin, а заканчиваются словом End;
Например:
If Z >0 Puis Commencer X:= 1; Y := -1 ; WriteLn('Informations acceptées'); Fin Sinon WriteLn('Erreur'); 33 CASE SELECT OPERATOR L'instruction de choix est utilisée pour remplacer les constructions d'instructions conditionnelles imbriquées. Syntaxe de la notation casuelle<порядковая_переменная>de<значение_1> : <оператор_1> ;
<значение_2> : <оператор_2> ;
………
<значение_N> : <оператор_N>Autre<оператор_N+1>; finir; Vous pouvez utiliser des parenthèses dans l'instruction select Chaîne facultative 34 SELECT STATEMENT CASE Cas Taille d'élève de 16..30 : Vous êtes un élève du primaire ; 31,32,33 : Vous êtes en classe 5-6 ; 34..50 : Vous êtes un étudiant du secondaire Une virgule est utilisée pour lister les valeurs, deux points pour sélectionner une plage Sinon Vous n'êtes clairement pas un étudiant ; finir; Cas x de -128..-1 : writeln('Négatif'); 0 : writeln('Nul'); 1..127: writeln('Positive') Sinon WriteLn('Out of range'); finir; 35 EXERCICE Ecrivez un programme qui, étant donné un nombre, affiche le jour de la semaine correspondant. Par exemple, entrez le chiffre 2, le programme devrait afficher 'mardi'. Si le nombre est en dehors de 1..7, un message doit s'afficher indiquant qu'il n'y a pas un tel jour. Matériel utilisé : Opérateur de sélection : Cas<порядковая_переменная>de<значение_1> : <оператор_1> ;
………
<значение_N> : <оператор_N>; Autre<оператор_N+1>; finir; 36 CYCLES 37 Les algorithmes sont dits cycliques, dans lesquels l'exécution de certains opérateurs est effectuée de manière répétée avec les mêmes données modifiées (par exemple, la procédure de multiplication des nombres par leur addition multiple). Il existe trois opérateurs de boucle en Pascal : For (boucle avec un paramètre ou pour un nombre de répétitions donné) While (boucle WHILE) Repeat (BEFORE loop) Si le nombre de répétitions est connu, alors il est préférable d'utiliser l'opérateur de boucle avec un paramètre. BOUCLE AVEC PARAMETRE 38 Boucle pour un nombre spécifié de répétitions avec valeur de paramètre croissante ou décroissante For (param) := (start_value) To (end_value) Do (operator) ; Corps de la boucle Remarques Le paramètre est un type entier ; Vous pouvez utiliser des parenthèses d'opérateur dans une boucle ; Vous ne pouvez pas modifier le paramètre de boucle dans le corps de la boucle ; Le paramètre de cycle est incrémenté de un ; Valeur de début > valeur de fin, sinon le corps de la boucle est ignoré ; Pour diminuer le paramètre, à la place de To, utilisez DownTo. BOUCLE AVEC PARAMETRE 39 Ecrire un programme qui demande des nombres entiers (a, b), où a
Sujet de leçon : "Cycles (répétition) dans les programmes"
1) Répéter et consolider les connaissances sur l'élaboration de programmes linéaires et ramifiés; 2) Apprendre à écrire des programmes en utilisant un opérateur cyclique - FOR i:=1 TO n DO Begin instructions (loop body) end ; 3) Appliquer les opérateurs à la résolution de problèmes typiques. Le but de la leçon :
Insertion manquante : Programme Sql ; Var A, B, C, D, XI, X2 : ??? ; Begin Writeln ("Entrez les coefficients de l'équation quadratique '); Readln (???); D:=B*B-4*A*C; If D
Questions au groupe : 1) Quelle est la différence entre les programmes ramifiés et linéaires ? 2) Avec l'aide de quels opérateurs le choix est-il fait dans les programmes ? 3) commencer….fin - Qu'est-ce que c'est ? Quelles sont les règles d'utilisation du programme ?
1) opérateurs d'E/S ; 2) Opérateurs de choix ; 3) a:=a+3 - que va-t-il se passer ? 4) Lister les types de données ; 5) Supprimez AND, OR, END, NOT, IF inutiles ; 6); - Qu'est-ce que ça veut dire? 7) Comment la fin du programme est-elle marquée ? 8) Énumérez les opérations arithmétiques. 9) Qu'est-ce que 120 mod 65 = ? 10) Déclarations de boucle.
Organisez en conséquence : 1. Lire 2. Fin 3. Début 4. Entier 5. ; 6. Si .. Alors 7. := 8. Entrée 9. Fin 10. Entiers 11. Affecter 12. Action suivante 13.Début 14.Si..alors
Le résultat est-il inférieur à 3 ? a:= 7 b:= - 10 a:=a*(- 7) b:=159 a:=b+a
Trouver 5 erreurs dans le programme : Program krug ; VAR Pi, r, S : réel ; Pi:=3.14, WRITELN('vvedite radiuc r='), READ(r); S=Pi*r*r ; ECRIT('Ploshad kruga S= ', S) fin
Cercle de programme ; VAR Pi, r, S : réel ; begin Pi:=3.14 , WRITELN('vvedite radiuc r=') , READ(r); S:=Pi*r*r ; ECRIT('Ploshad kruga S= ', S) end .
Tâche №1 Étant donné un entier N , déterminez s'il est pair ou impair. 2, 4, 6, ... sont pairs, car divisé sans reste par 2(N mod 2 =0) 1, 3, 7, ... - impair, car divisé par 2 avec reste 1(N mod 2 =1)
Algorithme Algorithme de Chislo ; var N : entiers ; start Output('vvedite chislo') ; Entrée (N) ; SI N mod 2 =0 T O Sortie(N,'- chetnoe'); SI N mod 2 =1 T O Output(N,'- nechetnoe'); la fin.
Tâche № 2 Étant donné un entier à deux chiffres N (DE), où D - le nombre de dizaines, E - unités. Déterminez si la somme des chiffres de ce nombre sera 10. Exemple : le 28 aura la somme S=2+8=10, mais le 27 n'aura pas S=2+7=9 On comptera les dizaines : D = N div 10 , et unités : E= N mod 10
Algorithme Algorithme de Chislo ; vars N,E,D,S : entiers ; start Output('vvedite chislo') ; Entrée (N) ; E = N mod 10 ; D = N div 10 ; S==E+D; SI S = 10 T O Sortie('summa= 10') Sinon ('summa10'); la fin.
Définition : Programmes dans lesquels le même type d'actions est répété plusieurs fois - programmes cycliques (avec répétition).
Tâche : Étant donné 100 nombres naturels de 1 à 100 (1,2,3, ... 99,100) Calculez leur somme et la sortie vers la variable S.
Algorithme de somme ; Variable i,S : entiers ; Début S :=0 ; Pour i :=1 à 100 répéter Début S := S + i corps Fin ; cycle Conclusion(s) Fin.
somme du programme ; VAR i , S : entier ; DébutS :=0 ; FOR i:=1 TO 100 DO begin S:=S+i body end ; fin de la boucle ECRITURE(S).
somme du programme ; VAR i , S : entier ; DébutS :=0 ; FOR i:=1 TO 100 DO begin S:=S+i ; corps WRITE('S', i, '=', s) de fin de boucle ; finir.
Le corps du cycle est constitué des actions mêmes qui doivent être répétées plusieurs fois. Nous enfermons le corps du cycle entre parenthèses d'opérateur début ... .. fin;
ALT + F9 - corrige les erreurs CTRL + F9 - lance le programme ALT + F5 - affiche le résultat
Tâche : 1) Afficher la colonne de la table de multiplication de n'importe quel entier N par des nombres de 1 à 10. Exemple : N = 5, alors la colonne sera comme ceci - 1*5=5 2*5=10 3*5= 15 i * N = P , où i change de …… .. 1…10 10*5=50
Devoir: commentez le programme pour la tâche "À propos de la colonne de la table de multiplication"
MERCI POUR VOTRE ATTENTION!
- 1 Pascal
- 2. Pascal Pascal a été développé par le scientifique suisse Niklaus Wirth. Pascal est considéré comme l'outil le plus important pour l'enseignement des méthodes de programmation structurée et depuis 1983, il a été introduit dans le programme des écoles pour les étudiants qui se spécialisent en informatique. À l'avenir, le langage Pascal a été amélioré et a acquis de nouvelles propriétés différentes de la version de l'auteur.
- 3. Pascal est relativement facile à apprendre, assez clair et logique, et étant le premier langage de programmation à apprendre, enseigne un bon style.
- 4. Comme les langages naturels, chaque langage de programmation a son propre style et ses propres règles. La syntaxe d'un langage de programmation est un ensemble de règles qui déterminent comment construire des programmes corrects à partir des caractères de l'alphabet.
- 5. Alphabet Pascal 26 lettres latines minuscules et 26 lettres latines majuscules : A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z trait de soulignement _ 10 chiffres : 0 1 2 3 4 5 6 7 8 9 signes d'opération : + - * / =<> < > <= >= := @ délimiteurs (séparateurs) : . , " () (. .) ( ) (* *) .. : ; spécificateurs : ^ # $
- 6. Structure du programme (1. en-tête de programme) programme Program_Name ; (2. section pour spécifier les modules utilisés) utilise List_of_Used_Modules ; (3. Section Description) étiquette Label_Descriptions ; constante Descriptions_Consts ; type TypeDescriptions ; var Variable_Descriptions ; procédure Descriptions_des_procédures_et_fonctions ; fonction exporte Descriptions of_Exported_Names ; (4. Section Déclaration) début Déclarations fin.
- 7. Structure de programme simplifiée (1. en-tête de programme) programme Program_Name ; (2. section pour spécifier les modules utilisés) utilise List_of_Used_Modules ; (3. Section Descriptions) const Descriptions_Consts ; var Variable_Descriptions ; (4. Section Déclaration) début Déclarations de programme fin.
- 8. Les commandes du langage de programmation sont appelées opérateurs Le séparateur d'opérateurs en Pascal est ; (point-virgule)
- 9. Un commentaire est un morceau de texte de programme, délimité par des symboles ( ). Les commentaires dans le programme remplissent une fonction d'information. (Mon premier programme) programmez d'abord; begin writeln('Hello, World!') end.
- 10. Exemple : rectangle périmètre programme périmètre ; (en-tête de programme) utilise crt ; (crt - nécessaire pour effacer l'écran) var a,b:integer; (déclaration de variable) P:entier ; Begin (démarrage du programme) clrscr ; (écran clair) a:=12 ; (on affecte la valeur 12 à la variable a) b:=7; (on affecte la valeur 7 à la variable b) P:=2*(a+b); (la valeur de l'expression est affectée à P) write("P = ",P); (afficher la valeur de P) fin. (fin du programme)
- 11. Le programme dans son travail traite des données. Certaines données sont définies avant le démarrage du programme, et après son démarrage, elles conservent leurs valeurs invariantes pendant toute la durée du programme. Ce sont des constantes. D'autres données peuvent changer pendant l'exécution du programme. Elles sont appelées variables.
- 12. La différence entre une variable et une constante est assez évidente : lors de l'exécution d'un programme, la valeur d'une variable peut être modifiée, mais pas la valeur d'une constante. variablesvariables constantesconstantes donnéesdonnées
- 13. Par variable, nous entendons une cellule ("boîte") dans laquelle un ordinateur peut écrire ("ajouter") des données. Par cellule, nous entendons vraiment un "morceau de mémoire" qui stocke des informations. Pour utiliser les informations stockées dans une cellule, chaque cellule doit avoir son propre nom ou, comme on le dit souvent, un identifiant. a b somme 5 3 8
- 14. Identifiants. Les noms (identifiants) sont les éléments du langage - constantes, étiquettes, types, variables, procédures, fonctions, modules, objets. Un identifiant est une séquence de lettres, de chiffres et de traits de soulignement qui commence par une lettre ou un trait de soulignement et ne contient pas d'espaces.
- 15. Le nom peut contenir n'importe quel nombre de caractères, mais 63 caractères sont significatifs. Il est interdit d'utiliser des mots de fonction et des noms standards comme noms dans le langage PASCAL, qui sont utilisés pour nommer des constantes standards, des types, des procédures, des fonctions et des fichiers. Exemples de noms de langage PASCAL : A b12 r1m SIGMA gamma I80_86
- 16. En Pascal, la différence entre les lettres minuscules et majuscules est ignorée, donc les noms NaMe et name sont identiques.
- 17. Un mot fonctionnel est un mot qui, dans la langue PASCAL, a une certaine signification sémantique qui ne peut pas être modifiée. Parfois, cela s'appelle un mot-clé.
- 18. Mots de service (réservés) : ABSOLUTE EXPORTS LIBRARY SET ASSEMBLER EXTERNAL MOD SHL AND FAR NAME SHR ARRAY FILE NIL STRING ASM FOR NEAR THEN ASSEMBLER FORWARD NOT TO BEGIN FUNCTION OBJECT TYPE CASE GOTO OF UNIT CONST IF OR UNTIL CONSTRUCTOR IMPLEMENTATION PACKED USES DESTRUCTOR IN PRIVATE VAR DIV INDEX PROCEDURE VIRTUAL DO INHERITED PROGRAM WHILE DOWNTO INLINE PUBLIC WITH ELSE INTERFACE RECORD XOR END INTERRUPT REPEAT EXPORT LABEL RESIDENT
- 19. Les espaces ne peuvent pas être utilisés à l'intérieur des caractères doubles et des mots réservés. Il y a des noms qu'on appelle standard. sin cos real true Contrairement aux mots de fonction, la signification des noms standards peut être redéfinie par le programmeur.
- 20. Ceci est une indication pour le compilateur de la quantité de mémoire à réserver pour les variables de notre programme. Dans le programme compilé, toutes les variables se voient allouer de l'espace en mémoire et toutes les variables se voient attribuer des valeurs nulles. Toutes les variables utilisées dans le programme doivent être déclarées dans la section de déclaration des variables après le mot réservé var. Déclaration de variables
- 21. Il existe différents types de données...
- 22. Types de données Les noms des types standards sont des identifiants prédéfinis et sont valables à tout moment du programme. Ils sont décrits dans le module standard Système, qui est inclus par défaut dans la liste des modules utilisés. Les types définis par l'utilisateur sont des types supplémentaires (simples et structurés) déclarés par l'utilisateur.
- 23. Types de données standard 1. groupe de types entiers (Shortint, Integer, Longint, Byte, Word); 2. groupe de types réels (Single, Real, Double, Extended, Comp); 3. logique (types booléens) (booléen, ByteBool, WordBool, LongBool) ; 4. caractère (Char); 5. chaîne (chaîne); 6. index (pointeur); 7. type de texte (Texte).
- 24. Groupe de types entiers Nom du type Type plage de valeurs mémoire requise Entier court signé Entier court -128 .. 127 1 octet Entier signé Entier -32768 .. 32767 2 octets Entier long signé Entier long -2147483648 .. 2147483647 4 octets Entier court non signé entier Octet 0 .. 255 1 octet Entier non signé Mot 0 .. 65535 2 octets
- 25 Varb : octet ; summa, count : nombre entier ; Déclaration de variables de type entier summa:= -365; Utiliser
- 26. Les nombres en PASCAL sont généralement écrits en notation décimale. Le signe positif du nombre peut être omis. Les nombres entiers sont écrits sous une forme sans point décimal, par exemple : 217 -45 8954 +483
- 27. Le groupe de types réels définit les données qui sont implémentées par un sous-ensemble de nombres réels. Var A : réelle ; commencer ... A:=0,65 ; … finir.
- 28. Nom du type Type Plage de valeurs Nombre de chiffres de la mantisse Taille (octets) Nombre réel simple précision Réel 2.9e-39 .. 1.7e+38 11 6 Nombre réel Simple 1.5e-45 .. 3.4e+ 38 7 4 Nombre réel de double précision Double 5.0e-324 .. 1.7e+308 15 8 Nombre réel de précision étendu Etendu 3.4e-4932 .. 1.1e+4932 19 10 Comp Réel Entier -9.2e+18 .. 9.2e +18 19 8
- 29. Les nombres réels sont écrits sous la forme avec un point décimal ou sous la forme utilisant l'ordre décimal, qui est représenté par la lettre E : 28,6 0,65 -0,018 4,0 5E12 -1,72E9 73,1E-16
- 30. Le type de données booléen correspond à l'identifiant booléen. Les variables booléennes ont une taille de 1 octet et peuvent contenir des valeurs VRAI ou FAUX. La valeur FALSE correspond à 0, tout nombre différent de zéro est considéré comme TRUE. Bouton Var, drapeau : booléen ; Bouton Démarrer :=vrai ;
- 31. Le type de caractère correspond à l'identificateur standard car. Les variables et les constantes de type caractère peuvent prendre des valeurs à partir d'un ensemble de caractères de code ASCII. Symbole var, bukva, z : char ; Déclaration de variables symboliques
- 32. Le type de chaîne correspond à l'identifiant standard String. VarS : chaîne ; (chaîne de 0 à 255 caractères) S2 : Chaîne ; (chaîne de 5 caractères)
- 33. Une chaîne de caractères est une séquence de caractères du jeu de caractères ASCII entre guillemets simples. Les chaînes en PASCAL sont une séquence de caractères écrite entre apostrophes. S'il est nécessaire d'utiliser l'apostrophe elle-même comme caractère significatif dans une chaîne, alors deux apostrophes doivent être écrites. Exemples de chaînes : "STRING" "STRING" "AD" "UTANT"
- Le type de caractère, ainsi que les types entiers et booléens, sont appelés types dits ordinaux. L'ensemble des valeurs valides de tout type ordinal est une séquence ordonnée, dont chaque élément a son propre numéro ordinal (à partir de 0).
- 35. La fonction Ord renvoie le nombre ordinal de cette valeur dans la déclaration de type. Ord(2)=2, Ord('0')=48 Writeln(ord('e')); WriteIn(ord('9'));
- 36. Table de codage ASCII ASCII (American Standard Code for Information Interchange; prononcé "asci") est un codage informatique pour représenter l'alphabet latin, les chiffres arabes, certains signes de ponctuation et les caractères de contrôle. Il a été introduit par l'American Standards Institute ANSI.
diapositive 1
LANGAGE DE PROGRAMMATION PASCAL Bogdanov Vladimir Présentations gratuites http://prezentacija.biz/diapositive 3
Le langage Pascal a été créé par Niklaus Wirth en 1968-1969 après sa participation aux travaux du comité de développement de la norme du langage Algol-68. La langue porte le nom du mathématicien, physicien, écrivain et philosophe français Blaise Pascal, qui a créé la première machine mécanique au monde qui additionne deux nombres. La première publication de Wirth sur le langage date de 1970, présentant le langage, l'auteur a indiqué comme objectif de sa création - la construction d'un langage petit et efficace qui favorise un bon style de programmation en utilisant une programmation structurée et des données structurées. Les travaux ultérieurs de Wirth visaient à créer un langage de programmation système basé sur Pascal, tout en conservant la capacité de mener un cours systématique et holistique de formation professionnelle en programmation sur sa base. Le résultat de ce travail est le langage Modula-2.
diapositive 4
UCSD Pascal Article principal : UCSD Pascal En 1978, le p-System UCSD a été développé à l'Université de Californie à San Diego, qui comprenait un portage du compilateur Wirth du langage Pascal en p-code portable, un éditeur de code source, un système de fichiers, etc., et a également implémenté un nombre important d'extensions du langage Pascal, telles que des modules, des chaînes de caractères de longueur variable, des directives de traduction, la gestion des erreurs d'entrée-sortie, la référence aux fichiers par leur nom, etc. Par la suite, les principales implémentations du langage Pascal se sont basées sur ce dialecte.
diapositive 5
Pascal Objet] Article principal : Pascal Objet En 1986, Apple a développé une extension objet du langage Pascal, résultant en Pascal Objet. Il a été développé par le groupe de Larry Tesler, qui a consulté Niklaus Wirth.
diapositive 6
En 1983, la première version de l'environnement de développement intégré Turbo Pascal de Borland est apparue, basée sur l'implémentation Pascal du même nom. En 1989, une extension de langage objet a été ajoutée à Turbo Pascal version 5.5. La dernière version (7.0) a été renommée Borland Pascal. Les fonctionnalités d'objet ont été empruntées à Object Pascal d'Apple, et il existe très peu de différences de langage entre Object Turbo Pascal 5.5 et Object Pascal d'Apple. Presque en même temps que Borland, Microsoft a publié sa version du langage orienté objet Pascal.] Cette version de Pascal n'était pas largement utilisée. Le développement ultérieur de l'implémentation Pascal de Borland a donné naissance à la variante Object Pascal de Borland, plus tard, au cours du développement de l'environnement de programmation Delphi, qui a reçu le même nom.
Diapositive 7
Une étape importante dans le développement du langage est l'émergence d'implémentations libres de Pascal l et GNU Pascl, qui ont non seulement absorbé les fonctionnalités de nombreux autres dialectes du langage, mais ont également assuré une portabilité extrêmement large des programmes qui y sont écrits (par exemple , GNU Pascal prend en charge plus de 20 plates-formes différentes, sous plus de 10 systèmes d'exploitation différents, Free Pascal fournit des modes de compatibilité spéciaux avec divers dialectes communs du langage, tels que Turbo Pascal (compatibilité totale), Delphi et autres). Depuis Delphi 2003, une implémentation de langage a été créée pour la plate-forme Net, bien que les développeurs continuent d'utiliser Delphi à partir de versions antérieures. On sait peu de choses sur le développement commercial en Free Pascal, GNU Pascal et TMT Pascal. En outre, la Southern Federal University a développé PascalABC.NET, le langage de programmation Pascal, qui inclut la plupart des fonctionnalités du langage Delphi, ainsi qu'un certain nombre de ses propres extensions. Il est basé sur la plate-forme Microsoft.NT et contient presque toutes les fonctionnalités du langage moderne : classes, surcharge d'opérateurs, interfaces, gestion des exceptions, classes et sous-routines génériques, récupération de place, expressions lambda.
Diapositive 8
Les caractéristiques du langage sont le typage strict et la disponibilité d'outils de programmation structurelle (procédurale). Pascal a été l'un des premiers langages de ce type. Selon Wirth, le langage devrait contribuer à une programmation disciplinée, par conséquent, avec un typage fort, les éventuelles ambiguïtés syntaxiques sont minimisées en Pascal, et l'auteur a essayé de rendre la syntaxe elle-même intuitive même lors de la première connaissance du langage.
Diapositive 9
Néanmoins, au départ, le langage présentait un certain nombre de limitations : l'impossibilité de passer des tableaux de longueur variable aux fonctions, le manque de moyens normaux de travailler avec de la mémoire dynamique, une bibliothèque d'E / S limitée, le manque de moyens pour connecter des fonctions écrites dans d'autres langues, le manque d'outils de compilation séparés, etc. Une analyse détaillée des lacunes du langage Pascal de cette époque a été réalisée par Brian Kernighan dans l'article "Pourquoi Pascal n'est pas mon langage de programmation préféré" (cet article est paru au début années 1980, lorsque le langage Modula-2, descendant du Pascal, s'est débarrassé de la plupart de ses défauts, ainsi que des dialectes plus développés du Pascal). Certaines lacunes de Pascal ont été corrigées dans la norme ISO de 1982, en particulier, des tableaux ouverts sont apparus dans le langage, ce qui a permis d'utiliser les mêmes procédures pour traiter des tableaux unidimensionnels de différentes tailles.
diapositive 10
Cependant, de nombreuses lacunes du langage n'apparaissent pas ou même deviennent des avantages lors de l'apprentissage de la programmation. De plus, par rapport au principal langage de programmation du milieu universitaire des années 1970 (qui était Fortran, qui présentait des inconvénients beaucoup plus importants), Pascal représentait une avancée significative. Dans les années 1980, Pascal est devenu la base de nombreux programmes éducatifs, dans certains cas, des langages de programmation d'enseignement spécialisés ont été créés sur sa base, par exemple, au début des années 1980 en URSS, Andrei Ershov a développé un langage de type Algol-Pascal apprendre aux écoliers les bases de l'informatique et de la technologie informatique "l'apprentissage du langage algorithmique".
diapositive 11
L'implémentation la plus célèbre de Pascal, qui a assuré la large diffusion et le développement du langage, est le Turbo Pascal de Borland, qui est ensuite devenu Pascal objet pour DOS (à partir de la version 5.5) et Windows et plus loin dans Delphi, dans lequel d'importantes extensions de langage ont été introduit. Les dialectes Pascal utilisés dans Turbo Pascal pour DOS et Delphi pour Windows sont devenus populaires en raison du manque d'autres implémentations commerciales réussies.
diapositive 12
Après le début de l'utilisation de Pascal en 1970, et l'émergence d'implémentations qui différaient non seulement par des ajouts, mais aussi par la syntaxe, la question de la standardisation du langage s'est posée. La norme linguistique a été développée par Niklaus Wirth en 1974 avec Kathleen Jensen. Plus tard, la norme internationale de l'ISO et l'américaine de l'ANSI ont été adoptées. À l'heure actuelle, il existe trois normes fondamentalement différentes : Pascal non étendu (original), Pascal étendu (étendu), Extensions orientées objet vers Pascal (extension Pascal orientée objet).
diapositive 13
diapositive 14
Syntaxe et constructions de langage Pascal, dans sa forme originale, est un langage purement procédural et comprend de nombreuses structures et constructions de type Algol avec des mots réservés comme si, alors, sinon, tandis que, pour, etc. Cependant, Pascal contient également un grand nombre de des fonctionnalités pour structurer les informations et les abstractions qui n'étaient pas présentes dans l'Algol-60 d'origine, telles que les définitions de type, les enregistrements, les pointeurs, les énumérations et les ensembles. Ces constructions ont été en partie héritées ou inspirées des langues Simula-67, Algol-64, créées par Niklaus Wirth AlgolW (anglais) russe. et suggéré par Hoare. Dans les dialectes modernes (Free Pascal), des opérations telles que la surcharge d'opérateurs et de fonctions sont disponibles.
diapositive 15
programme p; début fin. Le programme ne fait rien et contient un bloc d'instructions vide. Un exemple de programme qui imprime la chaîne "Hello, world!" :
diapositive 16
begin writeln("Hello, World!"); (opérateur de sortie de ligne) fin.
diapositive 17
diapositive 18
diapositive 19
diapositive 20
En Pascal, les opérations au niveau du bit sont autorisées sur les types entiers (octet, entier court, mot, entier, entier long et leurs plages). Opérations logiques sur les bits : Les opérations logiques décrites précédemment peuvent être effectuées sur les bits de deux opérandes entiers : not, and, or, xor. La différence entre les opérations au niveau du bit et les opérations logiques est que les opérations au niveau du bit (au niveau du bit) sont effectuées sur des bits individuels des opérandes, et non sur leur valeur en représentation décimale (généralement). Le concept de types de données ordinaux (ordinal) est distingué, ceux-ci incluent les types entiers (signé et non signé), logique (booléen), caractère (char), les types énumérés et les types de plage. Les types ordinaux sont spécifiés par un entier (code), qui peut être obtenu à l'aide de la fonction ord. Toutes les opérations effectuées sur les types ordinaux sont effectuées sur leurs codes.
diapositive 21
diapositive 22
Pour les types ordinaux, les opérations inc, dec, succ, pred, ord, opérations de comparaison (=>
diapositive 23
diapositive 24
diapositive 25
Dans le Pascal de Jensen et Wirth, les chaînes étaient représentées comme des tableaux compacts de caractères ; par conséquent, ils avaient une longueur fixe et étaient généralement rembourrés à cette longueur avec des espaces. En Pascal moderne, pour travailler avec des chaînes, le type intégré chaîne est utilisé, qui prend en charge la concaténation (+) et la comparaison (> =
diapositive 26
Le type string [n] ou simplement string dans les dialectes du langage des années 1970-1990 était défini comme un tableau de caractères array of char (n par défaut à 80 en UCSD Pascal et 255 en Turbo/Borland Pascal), le caractère nul code dans cette représentation sert à définir la longueur de la chaîne, respectivement, la chaîne peut avoir une taille maximale de 255 caractères. Par défaut, dans Delphi et FreePascal, le type AnsiString est utilisé comme une chaîne, dont la mémoire est dynamiquement allouée et libérée par le compilateur, et la taille de chaîne maximale dans les implémentations actuelles est de 2 gigaoctets. De plus, dans Delphi et Free Pascal, le type WideString peut être utilisé comme une chaîne, où une représentation 16 bits des caractères dans l'encodage UCS-2 est utilisée, alors qu'il n'y a pas d'outils pour convertir des chaînes à un octet en chaînes multioctets. et de retour dans la bibliothèque standard du langage.
diapositive 27
De nouveaux types peuvent être définis à partir de ceux existants : type (section de déclaration de type) x = Integer ; y=x ;
diapositive 28
De plus, les types composites peuvent être construits à partir de types primitifs : type ( section de déclaration de type ) a = Array of Integer; (définition de tableau) b = enregistrement (définition d'enregistrement) x : nombre entier ; y : Char ; finir; c = Fichier de a ; (définition de fichier)
diapositive 29
Les types de fichiers en Pascal sont divisés en typés, texte et fichiers sans types. Comme le montre l'exemple ci-dessus, les fichiers typés en Pascal sont des séquences d'éléments du même type. Pour chaque fichier, il existe une variable de pointeur de tampon, notée f^. Les procédures get (pour la lecture) et put (pour l'écriture) déplacent le pointeur vers l'élément suivant. La lecture est implémentée de sorte que read(f, x) soit identique à get(f); x:=f^. En conséquence, l'écriture est implémentée de telle manière que write(f, x) est identique à f^ := x; mettre(f). Les fichiers texte texte sont définis comme une extension du fichier de type char et, en plus des opérations classiques sur les fichiers typés (lecture, écriture d'un caractère), permettent l'entrée-sortie de caractères dans un fichier de tous types de données, similaire à l'entrée-console. sortir.
diapositive 30
Les fichiers sans types sont déclarés comme des variables de type fichier. Avec eux, il est possible d'effectuer des opérations d'E / S non typées octet par octet pour plusieurs blocs d'octets d'une longueur spécifiée via un tampon, à cet effet des procédures spéciales de lecture de bloc et d'écriture de bloc (extension UCSD) sont utilisées.
diapositive 31
diapositive 32
diapositive 33
diapositive 34
diapositive 35
Pointeurs Pascal supporte l'utilisation de pointeurs (type ^type et pointeur non typé) : type a = ^b; b = enregistrement x : Entier ; y : Char ; z:a ; finir; var pointer_to_b:a ;
diapositive 36
Ici, la variable pointer_to_b est un pointeur vers le type de données b, qui est un enregistrement. Le type d'un pointeur typé peut être spécifié avant la déclaration du type auquel il se réfère. Il s'agit d'une exception à la règle selon laquelle tout élément doit être déclaré avant de pouvoir être utilisé. L'introduction de cette exception a permis d'organiser des définitions récurrentes de structures de données, telles que des listes linéaires, des piles et des files d'attente, incluant un pointeur vers une entrée dans la description de cette entrée (voir aussi : pointeur nul - nil). Un pointeur typé a une opération de déréférencement (sa syntaxe : pointer^). Pour créer une nouvelle entrée et affecter la valeur 10 et le caractère A aux champs x et y qu'elle contient, les instructions suivantes sont requises :
Diapositive 37
nouveau(pointeur_vers_b); (allocation de pointeur) pointer_to_b^.x:= 10; (déréférencement du pointeur et accès au champ d'enregistrement) pointer_to_b^.y:= "A" ; pointer_to_b^.z:= néant ; ... disposer(pointer_to_b); (libération de la mémoire sous le pointeur)
diapositive 38
Vous pouvez également utiliser l'instruction with pour faire référence à des champs dans des enregistrements et des objets, comme illustré dans l'exemple : new(pointer_to_b); avec pointer_to_b^ do begin x:= 10; y:= "A" ; z := fin nulle ; ... disposer(pointer_to_b);
Diapositive 39
Type procédural Dans le langage original de Pascal Jensen et Wirth, le type procédural n'était utilisé que pour décrire un paramètre formel. Déjà dans TP, il y avait un type procédural complet. La déclaration de type contient l'en-tête d'une procédure ou d'une fonction (sans nom), qui décrit généralement l'interface de la sous-routine. Une valeur de ce type contient un pointeur vers un sous-programme avec un titre correspondant à celui déclaré dans la déclaration de type. Un identificateur de variable peut être utilisé pour appeler la procédure ou la fonction appropriée.
diapositive 40
Pascal est un langage de programmation structuré, ce qui signifie qu'un programme se compose d'instructions standard individuelles exécutées de manière séquentielle, idéalement sans l'utilisation de la commande GOTO.
diapositive 41
Dans les instructions while, for, if, case, un bloc peut être utilisé comme instruction exécutée. Une telle construction, qui est une instruction ou un bloc ordinaire, est appelée une instruction complexe. Dans Turbo Pascal, pour contrôler le processus de compilation, il existe des directives qui sont placées dans des commentaires et vous permettent de changer de mode de fonctionnement du compilateur - par exemple, activer et désactiver les vérifications des opérations d'E/S, les débordements :
diapositive 42
En Pascal, les sous-programmes sont divisés en procédures et en fonctions : Syntaxiquement, les procédures et les fonctions consistent en un en-tête (contenant le mot clé procédure ou fonction, un nom pouvant être suivi d'une description des paramètres passés entre parenthèses, un type de retour, séparés par un caractère deux-points pour les fonctions et un point-virgule pour les procédures ), l'en-tête est suivi du corps suivi du caractère ;.
diapositive 43
Le corps d'une procédure, comme un programme, peut à son tour contenir des descriptions de procédures et de fonctions. Ainsi, les procédures et les fonctions peuvent être imbriquées les unes dans les autres aussi profondément que souhaité, tandis que le corps du programme est le plus haut de la chaîne. De plus, le contenu des sections de la description des variables, types, constantes, corps externes (procédures, fonctions, programmes) situées avant la description de la procédure/fonction sont disponibles à l'intérieur de celle-ci. De plus, dans la plupart des dialectes, vous pouvez accéder aux paramètres d'une procédure externe à partir d'une procédure. Après l'en-tête des procédures/fonctions, à la place du corps, le mot-clé forward peut être placé, cela se fait si la description de la procédure/fonction se trouve dans le programme après son appel, et est associée à la possibilité de compiler le programme en une passe appuyée en Pascal. Les procédures diffèrent des fonctions en ce sens que les fonctions renvoient une valeur, contrairement aux procédures.
diapositive 44
Avant l'avènement des modules liés dans leur forme moderne, certaines implémentations de Pascal prenaient en charge la modularité via un mécanisme d'inclusion de fichiers d'en-tête, similaire au mécanisme #include en C : en utilisant une directive spéciale formatée comme un pragma, par exemple, ($INCLUDE " file"), le contenu du fichier spécifié a été directement inclus dans le texte du programme sous sa forme textuelle d'origine. Ainsi, il était possible de diviser le code du programme en plusieurs fragments, pour faciliter l'édition, mais avant la compilation, ils étaient automatiquement combinés en un seul fichier de programme, qui était finalement traité par le compilateur. Cette implémentation de la modularité est primitive et présente de nombreux défauts évidents, elle a donc été rapidement remplacée. Les implémentations Pascal modernes (à partir de UCSD Pascal) prennent en charge les modules. Les modules de programme peuvent être de deux types : le module de programme principal, qui, comme d'habitude, commence par le mot-clé program et dont le corps contient du code exécuté après le chargement du programme en mémoire, et des modules auxiliaires contenant des types, des constantes, des variables, des procédures et les fonctions destinées à être utilisées dans d'autres modules, y compris le module principal.
diapositive 45
La structure générale d'un plug-in en Pascal est la suivante : unit UnitName1 ; interface ... implémentation ... début (peut être omis - utilisé si des instructions d'initialisation doivent être placées) ... fin.
diapositive 46
Une autre option est également possible : unit UnitName2 ; interface ... implémentation ... initialisation ... finalisation .... fin.
diapositive 47
Contrairement au programme principal, un fichier d'unité commence par le mot-clé UNIT suivi du nom de l'unité et d'un point-virgule. Les implémentations modernes exigent généralement que le nom d'un module soit le même que le nom du fichier de code source qui contient le module. Un module contient trois sections : une section d'interface, une section d'implémentation et un corps de module.
diapositive 48
La section d'interface vient en premier, commence par le mot-clé INTERFACE et se termine au point du module où commence la section ou le corps d'implémentation. La section interface déclare les objets (types, constantes, variables, procédures et fonctions - des en-têtes sont placés pour eux) qui doivent être disponibles depuis l'extérieur du module. Dans ce cas, une déclaration partielle des types est autorisée : ils peuvent être déclarés sans spécifier de structure, avec un seul nom. Lors de l'utilisation de ce type dans un programme externe, il est permis de déclarer des variables et des paramètres de ce type, d'attribuer des valeurs, mais il est impossible d'accéder aux détails de sa mise en œuvre. Les procédures et les fonctions de la section interface sont déclarées en tant que forwards - des en-têtes avec des paramètres, mais sans corps. La composition de la section interface du module est telle qu'elle est suffisante pour générer du code utilisant ce module. Les variables déclarées dans la section interface sont globales, c'est-à-dire qu'elles existent dans une seule instance et sont disponibles dans toutes les parties du programme qui utilisent ce module.
diapositive 49
La section d'implémentation suit la section d'interface et commence par le mot-clé IMPLEMENTATION. Il contient des descriptions de procédures et de fonctions déclarées dans la section interface, ainsi que des descriptions de types, de constantes, de variables, de procédures et de fonctions nécessaires pour implémenter des procédures et des fonctions d'interface. La description d'une procédure ou d'une fonction déclarée dans une section d'interface doit avoir exactement le même en-tête que dans la déclaration. Le corps peut utiliser d'autres procédures et fonctions de ce module, déclarées à la fois dans la partie interface et dans la section implémentation. Les variables déclarées dans la section d'implémentation sont, en fait, globales (c'est-à-dire qu'il n'y a qu'une seule instance de chacune de ces variables dans tout le programme), mais elles ne sont accessibles qu'à partir des procédures et fonctions décrites dans la section d'implémentation de ce module, ainsi que de son corps. S'il existe des déclarations de type abrégées dans la section interface, ces types doivent être entièrement déclarés dans la section implémentation.
Diapositive 50
Le corps d'un module commence par le mot clé BEGIN au niveau d'imbrication supérieur. Le corps contient le code du programme qui est exécuté une fois lorsque le module est chargé. Le corps peut être utilisé pour l'initialisation, l'attribution de valeurs initiales aux variables de module, l'allocation de ressources pour son fonctionnement, etc. Le corps du module est peut-être manquant. Dans un certain nombre d'implémentations Pascal, par exemple, dans Delphi, deux sections (également facultatives) peuvent être utilisées à la place du corps du module - INITIALIZATION et FINALIZATION. Ils sont placés à la fin du module, après le mot-clé correspondant. La première, la section d'initialisation, contient le code qui doit être exécuté au chargement du module, la seconde, la section de finalisation, contient le code qui sera exécuté au déchargement du module. La section de finalisation peut effectuer des actions inverses de l'initialisation - supprimer des objets de la mémoire, fermer des fichiers, libérer des ressources allouées. Le module se termine par le mot clé END suivi d'un point.
diapositive 51
Pour utiliser un module, le programme principal ou un autre module doit importer le module, c'est-à-dire contenir une déclaration de son utilisation. Cette déclaration est faite avec une instruction d'inclusion de module, qui est le mot-clé USES suivi des noms séparés par des virgules des modules à inclure. L'instruction de connexion doit suivre immédiatement l'en-tête du programme, ou après le mot-clé INTERFACE si la connexion est réalisée dans un module.
diapositive 52
Les modules connectés dans la section d'interface peuvent être utilisés dans l'ensemble du module - à la fois dans la section d'implémentation et dans le corps. Mais la section d'implémentation peut avoir sa propre instruction include (elle suit le mot-clé IMPLEMENTATION) contenant les noms des plug-ins qui ne sont pas dans la section d'interface mais qui sont nécessaires à la section d'implémentation. Une des raisons d'utiliser une liste de connexion distincte pour la section d'implémentation est lorsque deux modules ou plus s'utilisent mutuellement. Afin d'éviter les références circulaires dans les déclarations d'utilisation de tels modules, au moins l'un d'entre eux doit inclure l'autre dans la section d'implémentation.
diapositive 53
Tous les objets déclarés dans les sections d'interface des modules peuvent être utilisés dans le programme où ces modules sont connectés. Les noms des objets importés depuis les plug-ins restent les mêmes et peuvent être utilisés directement. Si deux ou plusieurs modules connectés ont des objets portant le même nom et que le compilateur ne peut pas les distinguer, une tentative d'utilisation d'un tel objet générera une erreur de compilation - spécification de nom ambigu. Dans ce cas, le programmeur doit appliquer la qualification de nom - spécifiez le nom au format ".".
diapositive 54
Des problèmes peuvent survenir s'il est nécessaire d'utiliser deux modules différents du même nom dans le programme. Si les modules ne sont disponibles que sous forme compilée (c'est-à-dire qu'il est impossible de changer leurs noms), il est impossible de les importer en même temps. Il n'y a pas de solution standard pour une telle collision au niveau du langage, mais des compilateurs spécifiques peuvent offrir l'un ou l'autre moyen de le contourner, en particulier le moyen d'attribuer des alias aux modules importés et de spécifier directement quel module prendre à partir de quel fichier.
Diapositive 55
Les modules sont conçus pour être compilés séparément - le compilateur n'a pas à compiler les modules importés pour compiler le module qui les utilise. Cependant, pour compiler correctement un module, le compilateur doit avoir accès à la section interface de tous les modules qu'il utilise. Il existe deux approches différentes, parfois combinées, pour organiser cet accès. Les modules sont compilés dans des fichiers binaires d'un format spécial (chaque compilateur a le sien), qui stockent des informations détaillées sur les objets déclarés dans la section interface, et peuvent également contenir le langage objet créé lors de la compilation du module, mais il n'utilise que la section interface du module. Si un module de bibliothèque est fourni sous une forme compilée (sans textes source complets), alors avec le fichier binaire il y a un fichier de code source tronqué du module contenant uniquement la section d'interface. Cela suffit au compilateur pour traiter correctement les appels des modules using, et au stade de la compilation du programme, l'éditeur de liens inclut simplement le fichier binaire dans le programme.
diapositive 56
Charger et décharger des modules Pour qu'un module fonctionne correctement, vous devrez peut-être effectuer certaines actions avant de commencer à l'utiliser : initialiser des variables, ouvrir les fichiers nécessaires, allouer de la mémoire ou d'autres ressources. Tout cela peut être fait dans le corps du module, ou dans la section d'initialisation. L'inverse de l'initialisation se fait dans la section de finalisation.
Diapositive 57
L'ordre d'initialisation et de finalisation des modules est indirectement déterminé par l'ordre de déclaration dans la section uses, mais pour les programmes compilés statiquement (où le module est soit compilé dans un fichier exécutable avec le programme principal, soit situé dans une bibliothèque dynamique séparée, mais chargé à l'étape de chargement initial), le compilateur garantit toujours que l'initialisation sera effectuée avant la première utilisation du module. La finalisation est effectuée lorsque le programme se termine, après la fin du module principal, de sorte que les modules utilisés sont finalisés plus tard que ceux qui les utilisent.
Diapositive 58
Dans le cas d'un chargement dynamique de modules contrôlés par le programmeur lui-même, les initialiseurs sont exécutés au chargement, c'est-à-dire qu'au moment où la commande de chargement du module a rendu le contrôle, son initialiseur a déjà été exécuté. Le finaliseur est exécuté après le déchargement, généralement lorsque la commande de déchargement du module est exécutée. Si cette commande n'est pas appelée, les modules chargés dynamiquement sont finalisés de la même manière que tous les autres - à la fin du programme.
Diapositive 59
La programmation orientée objet (POO) est une technologie de création de logiciels complexes basée sur la représentation d'un programme sous la forme d'un ensemble d'objets, dont chacun est une instance d'une certaine classe, et les classes forment une hiérarchie avec héritage de propriété.
diapositive 60
Le principal avantage de la POO est la réduction du nombre d'appels inter-modules et la réduction de la quantité d'informations transférées entre modules. Ceci est réalisé par une localisation plus complète des données et une intégration avec les routines de traitement.
diapositive 61
Les principaux inconvénients de la POO sont une certaine diminution des performances en raison de l'organisation plus complexe du système logiciel, ainsi que, en règle générale, une augmentation notable de la quantité de code binaire (en particulier lors de l'utilisation de bibliothèques de classes standard dans de petits programmes) en raison au fait que la plupart des compilateurs et éditeurs de liens modernes ne sont pas en mesure d'identifier et de supprimer tout le code qui tombe dans des classes inutilisées, des méthodes virtuelles et d'autres éléments POO.
Diapositive 62
En Pascal Objet, les classes sont définies à l'aide du type d'objet, similaire à record, qui, en plus des champs de données, peut contenir des en-têtes de procédure et de fonction (on les appelle des méthodes). Les noms des méthodes décrites suivent le nom de classe séparé par un point.
diapositive 63
Le constructeur et le destructeur sont spécifiés comme des procédures normales, mais au lieu de l'identificateur de procédure, les mots-clés constructeur et destructeur sont spécifiés. Par conséquent, contrairement aux langages de type C++, ils ont un nom différent du nom de la classe, il peut y avoir plusieurs destructeurs et ils peuvent avoir des paramètres (en pratique, cette fonctionnalité est rarement utilisée, généralement une classe a un seul destructeur Destroy qui remplace le destructeur virtuel destructeur de la classe parente).
diapositive 64
L'héritage unique, le polymorphisme de classe, le mécanisme de méthode virtuelle sont pris en charge (le mot virtuel après l'en-tête de méthode de classe). Il existe également des méthodes dynamiques (dans TP, elles sont décrites en ajoutant un entier après le mot virtual et sont principalement utilisées pour le traitement des messages ; dans Delphi et FreePascal, le mot message est utilisé à cette fin, et le mot dynamique est utilisé pour créer des méthodes dynamiques), qui diffèrent par une utilisation moindre de la mémoire et une vitesse d'appel moindre en raison de l'absence de duplication des méthodes dynamiques des ancêtres dans le VMT de l'enfant (cependant, FreePascal ne fait pas de distinction entre les méthodes virtuelles et dynamiques). Dans Delphi, FPC a implémenté la surcharge des opérations, des méthodes abstraites, des directives privées, protégées, publiques, publiées (par défaut, les membres de la classe sont publics) :
Diapositive 65
Dans le dialecte Delphi, les classes peuvent également être construites à l'aide du mot classe (de plus, l'héritage mutuel avec les classes d'objets n'est pas autorisé) et des interfaces (interface) sont introduites - toutes les méthodes sont abstraites et ne peuvent pas contenir de champs de données. Toutes les classes (créées avec la classe) héritent de TObject, toutes les interfaces dérivent de IUnknown. Les classes créées avec class peuvent implémenter plusieurs interfaces.
diapositive 66
Des interfaces ont été introduites dans Delphi pour prendre en charge la technologie COM de Microsoft. Les classes (Class), contrairement aux classes ordinaires (Object), n'ont pas besoin d'allocation/désallocation de mémoire explicite, la mémoire pour elles est allouée dynamiquement par un constructeur nommé Create, appelé avec le nom de la classe, et libéré lorsqu'un destructeur appelé Destroy est appelé (ils peut avoir d'autres noms) . Une variable d'une telle classe, contrairement à la classe objet, stocke l'adresse d'une instance de classe en mémoire, la valeur nulle est utilisée pour indiquer une référence vide, donc, pour libérer un objet, une méthode libre spéciale est définie dans TObject, qui vérifie la référence à nil et appelle le destructeur virtuel Destroy. Le code utilisant de telles classes ressemblerait à ceci :
Diapositive 67
Transfert d'informations via des canaux de communication techniques
Département de Biologie Médicale, Microbiologie, Virologie et Immunologie Adénovirus
Présentation sur l'informatique "Qu'est-ce que la programmation ?
Présentation sur le thème "dispositif et principe de fonctionnement du générateur"
Présentation sur le thème "Réseau mondial INTERNET
Présentation "Le rôle de l'information dans la vie de la société" Présentation sur le thème de l'information dans la vie de la société
Des briques à nos jours : L'évolution des téléphones portables