La leçon couvre les principaux types de données standards en Pascal, la notion de variable et de constante ; explique comment travailler avec des opérations arithmétiques

Pascal est un langage de programmation typé. Cela signifie que les variables qui stockent les données sont d'un type de données spécifique. Ceux. Le programme doit indiquer directement quelles données peuvent être stockées dans une variable particulière : données texte, données numériques, si numériques, alors entières ou fractionnaires, etc. Ceci est nécessaire principalement pour que l'ordinateur « sache » quelles opérations peuvent être effectuées avec ces variables et comment les effectuer correctement.

Par exemple, l'ajout de données texte, ou comme on l'appelle correctement en programmation - la concaténation - est la fusion habituelle de chaînes, tandis que l'ajout de données numériques se produit au niveau du bit, de plus, les nombres fractionnaires et entiers sont également ajoutés différemment. Il en va de même pour les autres opérations.

Examinons les types de données les plus courants en Pascal.

Types de données entiers en Pascal

Taper	Gamme	Mémoire requise (octets)
octet	0..255	1
raccourci	-128..127	1
entier	-32768.. 32767	2
mot	0..65535	2
entier long	-2147483648..2147483647	4

Vous devez garder à l'esprit que lorsque vous écrivez des programmes en Pascal entier(traduit de l'anglais dans son ensemble) est le plus fréquemment utilisé, car la plage de valeurs​​est la plus demandée. Si une plage plus large est nécessaire, utilisez entier long(entier long, traduit de l'anglais par entier long). Taper octet en Pascal, il est utilisé lorsqu'il n'est pas nécessaire de travailler avec des valeurs négatives, il en va de même pour le type mot(seule la plage de valeurs ici est beaucoup plus large).

Exemples de la façon dont les variables sont décrites (déclarées) en Pascal :

programme a1 ; var x,y:entier; (type entier) monnom:string; (type de chaîne) start x:=1; y:=x+16; monnom:="Pierre"; writeln("nom : ",monnom, ", âge : ", y) end.

Résultat:
nom : Peter, âge : 17 ans

Commentaires en Pascal

Remarquez comment les commentaires sont utilisés en Pascal. Dans les commentaires de l'exemple, c'est-à-dire le texte du service qui n'est « pas visible » pour le compilateur est placé entre accolades. En règle générale, les programmeurs font des commentaires pour expliquer des morceaux de code.

Tâche 3. La population de Moscou est de = 9 000 000 d'habitants. La population de Nouveau Vasyuki est de 1 000 habitants. Écrivez un programme qui détermine la différence du nombre d'habitants entre deux villes. Utiliser des variables

Types de données réels en Pascal

Les nombres réels en Pascal et en programmation en général sont le nom des nombres fractionnaires.

Taper	Gamme	Mémoire requise (octets)
réel	2,9 * 10E-39 .. 1,7 * 10E38	6
célibataire	1,5 * 10 E-45 .. 3,4 * 10E38	4
double	5*10E-324..1.7*10E308	8
étendu	1,9 * 10E-4951 .. 1,1 * 10E4932	10

Le type réel en Pascal est le type réel le plus couramment utilisé.

Ce qui précède a été présenté types de données simples en Pascal, qui incluent :

• Ordinal
• Entier
• casse-tête
• Personnage
• Répertoriable
• Intervalle
• Réel

Pour afficher les valeurs des variables de type réel, une sortie formatée est généralement utilisée :

le format utilise soit un nombre, indiquant le nombre de positions attribuées à ce nombre sous forme exponentielle ;

p:=1234,6789; Écrire(p:6:2); (1234.68)

Outre les types simples, le langage utilise également types de données structurées et pointeurs, qui fera l'objet de leçons ultérieures sur Pascal.

Constantes en Pascal

Souvent, dans un programme, on sait à l'avance qu'une variable prendra une valeur spécifique et ne la changera pas tout au long de l'exécution de l'ensemble du programme. Dans ce cas, vous devez utiliser une constante.

La déclaration d'une constante en Pascal a lieu avant la déclaration des variables (avant le mot de service var) et ressemble à ceci :

Un exemple de description de constante en Pascal :

1 2 3 4 5 6

constx= 17 ; var monnom : chaîne ; commencer monnom : = "Pierre" ; writeln ("nom : " , monnom, ", âge : " , x) end .

const x = 17 ; var monnom:string; commencer monnom:="Pierre"; writeln("nom : ",monnom, ", âge : ", x) end.

« Belle » sortie d’entiers et de nombres réels

Afin de garantir qu'après l'affichage des valeurs des variables, il y ait des retraits, afin que les valeurs ne « fusionnent » pas les unes avec les autres, il est d'usage d'indiquer par deux points combien de caractères doivent être fournis pour afficher le valeur:

Opérations arithmétiques en Pascal

Ordre des opérations

1. évaluation des expressions entre parenthèses ;
2. multiplication, division, div, mod de gauche à droite ;
3. addition et soustraction de gauche à droite.

Procédures et fonctions arithmétiques standard Pascal

Ici, il vaut la peine de s'attarder plus en détail sur certaines opérations arithmétiques.

• L'opération inc en Pascal, prononcée incrément, est une procédure Pascal standard qui signifie augmenter de un.

Exemple d'opération d'inc :

x:=1 ; Inc(x); (Augmente x de 1, c'est-à-dire x=2) writeln(x)

Utilisation plus complexe de la procédure inc :
Inc(x,n) où x est un type ordinal, n est un type entier ; la procédure inc incrémente x de n.

• La procédure Dec en Pascal fonctionne de la même manière : Dec(x) - diminue x de 1 (décrémentation) ou Dec(x,n) - diminue x de n.
• L'opérateur abs représente le module d'un nombre. Cela fonctionne comme ceci :

une : =- 9 ; b:=abs(a) ; (b=9)

une :=-9 ; b:=abdos(a); (b=9)

• L'opérateur div en Pascal est souvent utilisé, car un certain nombre de tâches impliquent le fonctionnement d'une division entière.
• Le reste de division ou l'opérateur mod en Pascal est également indispensable pour résoudre un certain nombre de problèmes.
• Il convient de noter la fonction impaire standard de Pascal, qui détermine si un entier est impair. Autrement dit, il renvoie vrai pour les nombres impairs, faux pour les nombres pairs.

Un exemple d'utilisation de la fonction impaire :

var x:entier; commencer x:=3; écrire(sqr(x)); (réponse 9) fin.

• Opération d'exponentiation en Pascal manque en tant que tel. Mais pour élever un nombre à une puissance, vous pouvez utiliser la fonction exp.

La formule est : exp(ln(a)*n), où a est un nombre, n est un degré (a>0).

Cependant, dans le compilateur Pascal abc, l'exponentiation est beaucoup plus simple :

var x:entier; commencer x :=9 ; écrire(sqrt(x)); (réponse 3) fin.

Tâche 4. Les dimensions d'une boîte d'allumettes sont connues : hauteur - 12,41 cm, largeur - 8 cm, épaisseur - 5 cm Calculez l'aire de la base de la boîte et son volume
(S=largeur*épaisseur, V=surface*hauteur)

Tâche 5. Le zoo compte trois éléphants et pas mal de lapins, le nombre de lapins changeant fréquemment. Un éléphant est censé manger cent carottes par jour et un lapin deux. Chaque matin, le gardien du zoo indique à l'ordinateur le nombre de lapins. L'ordinateur, en réponse à cela, doit indiquer au préposé le nombre total de carottes qui doivent être données aujourd'hui aux lapins et aux éléphants.

Tâche 6. Il est connu que X kg de bonbons coûte un roubles Déterminez combien cela coûte oui kg de ces bonbons, et aussi combien de kilogrammes de bonbons peuvent être achetés chez k roubles Toutes les valeurs sont saisies par l'utilisateur.

Connaître et comprendre les types de données fait partie intégrante de la programmation.

Dans cette leçon, nous découvrirons les types de données dans le langage de programmation Turbo Pascal.

En langage Pascal, tous les objets, c'est-à-dire les constantes, variables, valeurs de fonction ou expressions sont caractérisées par leurs types. Un type définit l'ensemble des valeurs valides pour un objet, ainsi que l'ensemble des opérations qui lui sont applicables. De plus, le type détermine le format de la représentation interne des données dans la mémoire de l'ordinateur. En termes de types d'objets, Pascal est un langage statique. Cela signifie que le type d'un objet, tel qu'une variable, est déterminé lors de sa déclaration et ne peut pas être modifié ultérieurement.

Structure des types de données en Pascal :

Types de langage simples
Les types simples incluent les types ordinal, réel, chaîne et adresse (pointeur). Ils définissent tous le type d’une seule valeur.

Types ordinaux caractérisé par le fait que chacun d'eux a un nombre fini de valeurs possibles, parmi lesquelles un ordre linéaire est établi. Chacune des valeurs peut être associée à un entier - son numéro de série.

Types entiers- désignent des ensembles d'entiers dans différentes plages. Il existe cinq types d'entiers, différant par la plage de valeurs valides et la taille de la RAM qu'elles occupent. Les types entiers sont désignés par des identifiants : Byte, ShortInt, Word, Integer, LongInt ; leurs caractéristiques sont indiquées dans le tableau suivant.

Les valeurs de types entiers sont écrites dans le programme de la manière habituelle :
123 4 -3 +345 -699
La présence d'un point décimal dans la notation d'un nombre entier est inacceptable. Ce serait une erreur d'écrire un entier comme celui-ci :
123.0
En plus de la notation décimale habituelle, il est possible d'écrire des entiers au format hexadécimal en utilisant le préfixe $, par exemple :
$01AF $FF $1A $F0A1B
La casse des lettres A, B, ..., F n'a pas d'importance.

Opérations valides :

• - affectation;
• - toute l'arithmétique : +, - ,*, /, div, mod (avec une division ordinaire [/] le résultat est réel !) ;
• - comparaison<, >, >=, <=, <>, =.

Type booléen- se compose de seulement deux valeurs : False (faux) et True (vrai). Les mots Faux et Vrai sont définis dans le langage et sont en fait des constantes logiques. La casse des lettres dans leur écriture n'a pas d'importance : FAUX = faux. Les valeurs de ce type sont le résultat de l'évaluation d'expressions conditionnelles et logiques et participent à toutes sortes d'opérateurs conditionnels du langage.
Opérations valides :

• - affectation;
• - comparaison:<, >, >=, <=, <>, =;
• - opérations logiques : NON, OU, ET, XOR

Type de caractère (Caractère)- il s'agit d'un type de données composé d'un seul caractère (signe, lettre, code). Une valeur Char peut être n’importe quel caractère du jeu de caractères ASCII. Si un symbole a une représentation graphique, alors dans le programme, il est écrit entre guillemets simples (apostrophes), par exemple :
"w" "s" "." "*" " "-(espace)
Pour représenter l'apostrophe elle-même, son image est doublée : """".
Si le caractère n'a pas de représentation graphique, par exemple un caractère de tabulation ou un caractère de retour chariot, vous pouvez alors utiliser une forme équivalente d'écriture de la valeur du caractère, composée du préfixe # et du code ASCII du caractère :
#9 #32 #13
Opérations valides :

• - affectation;
• - comparaison:<, >, >=, <=, <>, =. Le caractère le plus grand est celui qui possède un numéro ASCII plus élevé.

Type de chaîne (Chaîne, Chaîne[n])- Ce type de données définit des séquences de caractères - chaînes. Le paramètre n spécifie le nombre maximum de caractères par ligne. S’il n’est pas spécifié, n=255 est supposé. Une valeur de type « chaîne » dans un programme est écrite sous la forme d'une séquence de caractères entourée de guillemets simples (apostrophes), par exemple
"C'est une chaîne"
"1234" est aussi une chaîne, pas un nombre
"" - ligne vide
Opérations valides :

• - affectation;
• - ajout (concaténation, fusion) ; par exemple, S:= "L'hiver"+" "+"est arrivé !";
• - comparaison:<, >, >=, <=, <>, =. Les chaînes sont considérées comme égales si elles ont la même longueur et sont équivalentes caractère par caractère.

Types réels- désignent des ensembles de nombres réels dans différentes plages. Il existe cinq types réels, différant par la plage de valeurs autorisées et la taille de la RAM occupée. Les types réels sont désignés par des identifiants : Real, Single, Double, Extended, Comp ; leurs caractéristiques sont indiquées dans le tableau suivant.

Type de composition bien que classé comme type réel, il s’agit en réalité d’un entier avec une très large plage de valeurs.
Les valeurs de types réels peuvent être écrites dans un programme de plusieurs manières :
1.456 0.000134 -120.0 65432
+345 0-45 127E+12
-1,5E-5 -1,6E+12 5E4 0,002E-6

Ce serait une erreur d’écrire un nombre réel comme celui-ci :
0,5 (correct 0,5)
12. (correctement 12,0 ou 12)

Un nombre réel sous forme à virgule flottante (forme scientifique) s'écrit sous forme de paire
<мантисса>E<порядок>
Cette désignation s'entend comme « la mantisse multipliée par dix à une puissance égale à l'ordre ». Par exemple,
-1,6E+12 correspond à -1,6 1012

Opérations valides :
- affectation;
- tout arithmétique : +, - ,*, / ;
- comparaison:<, >, >=, <=, <>, =.

Lorsque vous comparez des nombres réels, n'oubliez pas qu'en raison de l'imprécision de leur représentation dans la mémoire de l'ordinateur (en raison de l'inévitabilité des arrondis), vous devez éviter d'essayer de déterminer l'égalité stricte de deux valeurs réelles. Il est possible que l’égalité soit fausse, même si ce n’est pas le cas.

Une plage ou (type restreint) n'est pas un type de langage prédéfini (tel que Integer ou Char) et n'est donc associée à aucun identifiant. Ce type est une entrée utilisateur. En l'utilisant, nous pouvons définir un nouveau type qui contiendra des valeurs uniquement provenant d'une sous-plage limitée d'un certain type de base. Le type de base ne peut être qu'un type entier, un type Char (caractère) et l'un des types d'énumération introduits par le programmeur.

Pour introduire un nouveau type - une plage - vous devez indiquer dans le bloc de description du type TYPE le nom du type saisi et les limites de la plage via le symbole de plage spécial ".." (deux points d'affilée) :
TAPER
Siècle = 1..21 ; (sous-plage de type entier)
Lettres majuscules = "A". "Z"; (sous-plage de type Char)

Types de langage structuré

Les types structurés incluent : un tableau, un enregistrement, un ensemble, un fichier, etc. Tous définissent le ou les types d'une structure de données.

Tableau- une structure ordonnée de données du même type qui les stocke séquentiellement. Le tableau doit avoir des dimensions qui déterminent le nombre d'éléments stockés dans la structure. Tout élément d'un tableau peut être atteint par son index.

Le type de tableau est déterminé par la construction :
Tableau [plage] de ElementType ;

La plage entre crochets indique les valeurs d'index du premier et du dernier élément de la structure. Exemples de déclarations de types et de variables :

TYPE Vecteur = tableau de Réel ; VAR V1 : Vecteur ; V2 : tableau d’octets ;
Ici, la variable V1 est définie en utilisant le type Vector décrit ci-dessus ; le type de variable V2 est construit directement au stade de sa description.

En tant que type d'élément de tableau, vous pouvez également spécifier un tableau, formant ainsi des structures multidimensionnelles. Par exemple, une description d'une structure bidimensionnelle (matrice) ressemblera à ceci :
VAR M1 : tableau de tableau d'octets ; La même chose peut être écrite de manière beaucoup plus compacte : VAR M2 : tableau d'octets ;
Ici, les tableaux M1 et M2 ont exactement la même structure : une matrice carrée de taille 3x3.

On accède à un élément de tableau en spécifiant son index, par exemple :

Writeln(V1); (affichage du premier élément du tableau V1) readln(M2); (saisie du troisième élément de la deuxième ligne de la matrice M2)
Ceci conclut la leçon sur les types de données, le texte a été presque entièrement copié et collé (le lien sera ci-dessous), car Je ne vois pas l’intérêt de raconter ce matériel avec mes propres mots. Si la différence entre les types de données est au moins un peu claire, alors c'est déjà bien.

Toutes les données - constantes, variables, valeurs de fonction - sont caractérisées en Pascal par un type de données.

Définissons le concept Type de données. Comme on le sait déjà, tous les objets du programme (variables, constantes, etc.) doivent être décrits.

Les descriptions informent le traducteur, d'une part, sur l'existence des variables et autres objets utilisés, et d'autre part, elles indiquent les propriétés de ces objets. Par exemple, la description d'une variable dont la valeur est un nombre indique les propriétés des nombres. Formellement, les nombres peuvent être entiers et réels (fractionnaires). En Pascal, comme dans d'autres langages de programmation, les nombres sont divisés en deux types : entier(mot entier réservé) et réel(mot réservé réel).

La séparation des nombres entiers en un type distinct s'explique par le fait que dans un ordinateur, les nombres entiers et réels sont représentés différemment : un nombre entier peut être représenté de manière absolument précise, mais un nombre réel comporte inévitablement une erreur finie, qui est déterminée par les propriétés du traducteur.

Par exemple, soit la variable x de type réel et sa valeur égale à un : x=1 . La valeur correspondante dans la mémoire de l'ordinateur peut être 0,999999999, 1,000000001 ou 1,000000000. Mais si la variable x est déclarée comme une variable de type entier, alors l'unité dans l'ordinateur sera représentée de manière absolument précise et la variable x ne pourra pas prendre de valeurs réelles (fractionnaires) - après tout, elle a été décrite comme une variable de type entier.

Ainsi, le type de données définit :

• représentation interne de données dans la mémoire d'un ordinateur;
• l'ensemble des valeurs que peuvent prendre des quantités de ce type ;
• opérations pouvant être effectuées sur des valeurs de ce type.

L'introduction de types de données est l'un des concepts de base du langage Pascal, à savoir que lors de l'exécution d'une opération d'affectation d'une variable à la valeur d'une expression, la variable et l'expression doivent être du même type. Cette vérification est effectuée par le compilateur, ce qui simplifie grandement la recherche d'erreurs et conduit à une fiabilité accrue du programme.

Les nombreux types de données du langage Turbo Pascal peuvent être divisés en deux groupes :

• types standard (prédéfinis) ;
• types définis par l'utilisateur (types définis par l'utilisateur) .

Les types Turbo Pascal standard incluent :

• type entier – entier ;
• type réel – réel ;
• type de caractère – char ;
• type booléen – booléen ;
• type de chaîne – chaîne ;
• type de pointeur – pointeur ;
• type de texte – texte.

Les types de données personnalisés sont diverses combinaisons de types standard.

Les types personnalisés incluent :

• type énuméré ;
• type d'intervalle ;
• type de pointeur ;
• types structurés ;
• type procédural.

Commentaire. Une autre classification des types de données est possible, selon laquelle les types sont divisés en simples et complexes.

Les types simples incluent : le type entier, le type réel, le type caractère, le type logique, le type énuméré et le type intervalle.

Un type complexe est constitué de diverses combinaisons de types simples (tableaux, enregistrements, ensembles, fichiers, etc.)

Types standards

Le type de données standard est défini par le langage Pascal lui-même. Lors de l'utilisation de types standards dans un programme, il suffit d'indiquer les sous-sections des types requis (const, var) puis de décrire les constantes et variables utilisées dans le programme. Il n'est pas nécessaire d'utiliser la sous-section Type.

Par exemple, si le programme utilise uniquement des variables :

je,j – entier (entiers);

x,y - réel (réel) ;

t,s - char (caractère) ;

a,b – booléen (logique),

alors seule une sous-section de variables est nécessaire - Var. Ainsi, dans la partie descriptive du programme, les déclarations de variables sont écrites comme suit :

Types entiers

Les données de ce type ne peuvent accepter que des valeurs entières. Dans un ordinateur, les valeurs de type entier sont représentées de manière absolument précise. Si la variable est négative, alors elle doit être précédée du signe « – » ; si la variable est positive, alors le signe « + » peut être omis. Ce type est nécessaire dans le cas où une quantité ne peut pas être représentée approximativement par un nombre réel. Par exemple, le nombre de personnes, d'animaux, etc.

Exemples d'écriture de valeurs entières : 17, 0, 44789, -4, -127.

La plage de variation des données d'un type entier est déterminée par cinq types standard d'entiers et est présentée dans le tableau :

Taper	Gamme	Taille en octets
Raccourci	-128...+128	1
Entier	-32768...32767	2
Entier long	-2147483648...2147483647	4
Octet	0...255	1
Mot	0...65535	2

Les deux derniers types représentent uniquement des nombres positifs et les trois premiers représentent à la fois des nombres positifs et négatifs.

Dans le texte du programme ou lors de la saisie de données de type entier, les valeurs sont écrites sans point décimal . Valeurs réelles des variables ne doit pas dépasser les valeurs admissibles le type (Shortint, Integer, Longint, Byte, Word) qui a été utilisé pour décrire la variable. Les éventuels excès lors des calculs ne sont en aucun cas contrôlés, ce qui entraînera un mauvais fonctionnement du programme.

Un exemple d'utilisation d'une variable entière

Var a:entier; b:mot; c:octet; Commencez a:=300; (a est défini sur 300) b:=300 ; (b réglé sur 300) c:=200 ; (c est réglé sur 200) a:=b+c; (a est défini sur 500) c:=b; (Erreur ! La variable c ne peut prendre que des valeurs de 255. Ici, la variable c est définie sur 500, ce qui entraînera un débordement du résultat.) Fin.

Types réels

Les valeurs de types réels sont représentées approximativement dans un ordinateur. La plage de variation des données de type réel est déterminée par cinq types standards : réel (Real), simple précision (Single), double précision (Double), précision étendue (Extended), complexe (Comp) et est présentée dans le tableau :

Taper	Gamme	Nombre de chiffres significatifs	Taille en octets
Réel	2,9E-39...1,7E+38	11-12	6
Célibataire	1,5E-45...3,4E+38	>7-8	4
Double	5E-324...1,7E+308	15-16	8
Étendu	3.4E-4951...1.1E+4932	19-20	10
Comp	-2E+63+1...+2E+63-1	19-20	8

Les nombres réels peuvent être représentés sous deux formats : virgule fixe et virgule flottante.

Le format d'écriture d'un nombre à virgule fixe est le même que la notation mathématique habituelle pour un nombre décimal avec une partie fractionnaire. La partie fractionnaire est séparée de la partie entière par un point, par exemple

34.5, -4.0, 77.001, 100.56

Le format de notation à virgule flottante est utilisé lors de l'écriture de nombres très grands ou très petits. Dans ce format, le nombre avant le « E » est multiplié par le nombre 10 à la puissance après le « E ».

1E-4	1*10-4
3.4574E+3	3.4574*10+3
4.51E+1	4.51*10+1

Exemples de nombres à virgule flottante :

Nombre	Enregistrement en Pascal
0,0001	1E-4
3457,4	34574E-1
45,1	451E-1
40000	4E+4
124	0,124E+3
124	1,24E+2
124	12,4E+1
124	1240E-1
124	12400E-2

Le tableau de 5 à 9 lignes montre un enregistrement du même nombre 124. En changeant la position de la virgule décimale dans la mantisse (le point « flotte », d'où le nom « enregistrement d'un nombre à virgule flottante ») et en même temps en modifiant la valeur de la commande, vous pouvez sélectionner les numéros d'enregistrement les plus appropriés.

Un exemple de description de variables de type réel.

Type de caractère

Les valeurs de type de caractère sont des caractères qui peuvent être saisis sur un clavier d'ordinateur. Cela vous permet de présenter du texte dans le programme et d'effectuer diverses opérations dessus : insérer, supprimer des lettres et des mots individuels, formater, etc.

Un type de caractère est désigné par le mot réservé Char et est conçu pour stocker un seul caractère. Les données de caractères occupent un octet en mémoire.

Format de déclaration des variables symboliques :

<имя переменной>: Char;

Lors de la définition de la valeur d'une variable caractère, le caractère est écrit en apostrophes. De plus, vous pouvez spécifier le caractère requis en spécifiant directement sa valeur de code numérique ASCII. Dans ce cas, vous devez faire précéder le chiffre indiquant le code ASCII du caractère recherché du signe #.

Un exemple d'utilisation de variables de type caractère :

Var c:char; (c est une variable de type caractère) Begin c:='A'; (la variable c reçoit le caractère 'A') c:=#65; (la variable c reçoit également le caractère A. Son code ASCII est 65) c:=’5’; (la variable c reçoit le symbole 5, Fin. Ici 5 n'est plus un nombre)

Type booléen

Le type de données logique est appelé Booléen en l'honneur du mathématicien anglais George Boole, créateur du domaine des mathématiques - la logique mathématique.

Format de déclaration d'une variable de type booléen :

<имя переменной>: booléen;

Les données de ce type ne peuvent prendre que deux valeurs :

• Vrai vrai;
• Le faux est un mensonge.

Les données logiques sont largement utilisées pour vérifier la validité de certaines conditions et pour comparer des quantités. Le résultat peut être vrai ou faux.

Pour comparer les données, les opérations relationnelles suivantes sont fournies :

Un exemple d'utilisation d'opérations relationnelles :

relation 5>3, résultat vrai ;

relation 5=3, résultat faux.

Un exemple d'utilisation de variables de type booléen.

Var a,b:booléen; (a,b sont des variables de type logique) Begin a:=True; (la variable a reçoit la valeur « vrai ») b:=false ; (la variable b est définie sur false) Fin.

Constantes

Des entiers, des nombres réels, des caractères, des chaînes de caractères et des constantes logiques peuvent être utilisés comme constantes.

Une constante doit être déclarée dans sa partie descriptive à l'aide du mot réservé const.

Format de déclaration constante

Const<имя константы>= <значение>;

Si un programme utilise plusieurs constantes, un seul mot-clé Const est autorisé et la description de chaque constante se termine par un point-virgule. Un bloc constant se termine par la déclaration d'une autre section ou la déclaration d'un bloc d'instructions exécutables.

Const (déclaration de section constante) année=2003 ; (constante de type entier, car il n'y a pas de point décimal dans l'enregistrement) time=14.05; (constante de type réel) N=24 ; (constante de type entier, car il n'y a pas de point décimal dans la notation) P=3,14 ; (constante de type réel) A=true ; (constante booléenne) str1='7'; (constante de type de caractère) str2='A'; (constante de type de caractère) str3='Turbo'; (constante de type chaîne) Var (déclaration de section variable) X,y:integer; (variables de type entier)

Types personnalisés

Parmi l'ensemble des types d'utilisateurs, nous considérerons uniquement

• type énuméré ;
• type d'intervalle.

Nous aurons besoin de ces deux types lors de l’étude des tableaux.

Type d'énumération

Un type de données énuméré décrit de nouveaux types de données dont les valeurs sont définies par le programmeur. Un type énuméré est spécifié par une énumération des valeurs qu'il peut recevoir. Chaque valeur est nommée par un identifiant et se trouve dans une liste entourée de parenthèses. Un type énuméré est un type de données défini par l'utilisateur, sa déclaration de type commence donc par le mot réservé TYPE.

Format du type d'énumération :

<имя типа>= (constante1, constante2,..., constanteN);

Où
constant1 , constant2 ,..., constantN – un ensemble ordonné de valeurs d'identifiant traitées comme des constantes.

Un exemple de description de type énuméré :

Tapez ball=(un, deux, trois, quatre, cinq) ; var t:balle;

Ici, ball est le nom du type énuméré ; un, deux, trois, quatre, cinq – constantes ; t est une variable qui peut prendre n'importe quelle valeur constante.

Dans un type énuméré, une constante est un identifiant, elle n'est donc pas citée et ne peut pas être un nombre. Ainsi, dans un type énuméré, une constante est un type particulier de constante qui ne peut pas être :

• constantes de type numérique : 1, 2, 3, 4, etc. ;
• constantes de type caractère : "a", "s", "1", "3", etc. ;
• constantes de type chaîne : "first", "second", etc.

De plus, les opérations arithmétiques et les procédures d'entrée et de sortie standard Lecture et Écriture ne sont pas applicables aux valeurs de ce type.

Un exemple d'utilisation de variables énumérées :

Tapez jours = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche) ; Jour Var : jours ; start if day = dimanche then writeln('Aujourd'hui c'est dimanche !'); Fin.

Les éléments inclus dans la définition d'un type énuméré sont considérés comme ordonnés dans l'ordre dans lequel ils sont énumérés. La numérotation commence à zéro. Ainsi, dans l'exemple donné, les jours de la semaine portent les numéros d'ordre suivants

Pour déterminer par programme le nombre ordinal, la fonction Ord() est utilisée.

Dans notre exemple, les numéros de séquence sont égaux :

Ord(lundi) = 0 ;

Ord(samedi) = 5 ;

Ord(dimanche) = 6.

Type d'intervalle

Si une variable n'accepte pas toutes les valeurs de son type, mais uniquement les valeurs contenues dans une certaine plage, alors ce type de données est appelé type d'intervalle. Le type d’intervalle est souvent appelé type limité et type de plage. Un type d'intervalle est défini par les limites de ses valeurs :

<минимальное значение>..<максимальное значение>

• deux caractères ".." sont traités comme un seul caractère, les espaces entre eux ne sont donc pas autorisés ;
• la bordure gauche de la plage ne doit pas dépasser sa bordure droite.

Le type d'intervalle est un type de données défini par l'utilisateur, sa déclaration de type commence donc par le mot de fonction TYPE.

Exemple de description d'un type d'intervalle :

Chiffre de type = 1..10 ; mois = 1..31 ; latitude = 'A'..'Z';

Types de données Pascal

Toutes les données (constantes, variables, valeurs de fonction ou expressions) dans Turbo Pascal sont caractérisées par leurs types. Un type définit l'ensemble des valeurs valides qu'un objet peut avoir, ainsi que l'ensemble des opérations valides qui peuvent lui être appliquées. Le type détermine également le format de la représentation interne des données dans la mémoire de l'ordinateur.

Il existe les types de données suivants dans Turbo Pascal.

1) Types simples :

- réel;

– symbolique ;

– Booléen (logique) ;

– énuméré;

- gamme limitée).

2) Types composites (structurés) :

– régulier (tableaux);

– combinés (enregistrements) ;

- déposer;

- plusieurs;

- chaîne;

- objets.

3) Types de référence (pointeurs typés et non typés).

4) Types procéduraux.

Turbo Pascal fournit un mécanisme pour créer de nouveaux types de données, grâce auquel le nombre total de types utilisés dans le programme peut être aussi grand que souhaité.

Type entier. Les valeurs entières sont les éléments d'un sous-ensemble d'entiers. Il existe cinq types entiers dans Turbo Pascal. Leurs noms, plage de valeurs, longueur de représentation en octets sont donnés dans le tableau. 6.

Tableau 6

Types de données entiers

Les variables entières sont décrites à l'aide des mots réservés ci-dessus :

i, j, k : entier ;

Les données de type entier sont stockées exactement en mémoire. Par exemple, les variables de type entier occupent 2 octets (16 bits) en mémoire, qui sont alloués comme suit : 1 bit est alloué pour stocker le signe du nombre (0 si le nombre est positif, et 1 si le nombre est négatif) et 15 bits pour stocker le nombre en binaire. Le nombre décimal maximum pouvant être écrit en binaire 15 bits est 32767.

Lorsque vous utilisez des procédures et des fonctions avec des paramètres entiers, vous devez être guidé par « l'imbrication » des types, c'est-à-dire partout où un mot est utilisé, l'octet est autorisé (mais pas l'inverse), l'entier long "inclut" un entier, qui, à son tour, inclut l'entier court.

Pour le type entier, cinq opérations de base sont définies dont le résultat est également un entier : +, -, *, div, mod (addition, soustraction, multiplication, division entière et reste de division entière). Dans les expressions arithmétiques, les opérations *, div, mod ont une priorité plus élevée que les opérations +, -. Exemples d'expressions écrites :

La liste des procédures et fonctions applicables aux types entiers est donnée dans le tableau. 7. Les lettres b, s, w, i, l désignent respectivement des expressions de type byte, shortint, word, integer et longint ; x est une expression de l’un de ces types ; les identifiants vb, vs, vw, vi, vl, vx désignent des variables des types correspondants. Un paramètre facultatif est indiqué entre crochets.

Tableau 7

Procédures et fonctions standard applicables à des types entiers

Appel	Type de résultat	Action
Abdos(x)	X	Module de retour x
Chr(b)	Carboniser	Renvoie un caractère par son code
Déc(vx[,i])	-	Diminue la valeur de vx de i, et en l'absence de i – de 1
Inc(vx[,i])	-	Augmente la valeur de vx de i, et en l'absence de i – de 1
Salut (je)	Octet	Renvoie l'octet de poids fort de l'argument
Salut (je)	Octet	Même
Lo(je)	Octet	Renvoie l'octet de poids faible de l'argument
Faible)	Octet	Même
Impair(l)	Octet	Renvoie vrai si l'argument est un nombre impair
Aléatoire (w)	Identique au paramètre	Renvoie un nombre pseudo-aléatoire uniformément distribué dans la plage 0…(w-1)
Carré(x)	X	Renvoie le carré de l'argument
Échanger(i)	Entier
Échange (w)	Mot	Échange des octets dans un mot
Succès(x)	Identique au paramètre	Renvoie la valeur entière suivante, c'est-à-dire x+1
Préd(x)	Identique au paramètre	Renvoie la valeur entière précédente, c'est-à-dire x-1

Lorsque vous travaillez avec des entiers, le type du résultat correspondra au type de l'opérande, et si les opérandes sont de types entiers différents, au type de l'opérande qui a la plage maximale de valeurs. Un éventuel débordement du résultat n'est pas contrôlé, ce qui peut entraîner des erreurs dans le programme.

Un vrai type. Les valeurs de types réels définissent un nombre arbitraire avec une certaine précision finie en fonction du format interne du nombre réel. Il existe cinq types réels dans Turbo Pascal (Tableau 8).

Tableau 8

Types de données réels

Les variables réelles sont décrites à l'aide des mots réservés ci-dessus :

Un nombre réel dans la mémoire de l'ordinateur se compose de 3 parties :

Chiffre de signe d'un nombre ;

Partie exponentielle ;

Mantisse du nombre.

La mantisse a une longueur de 23 (simple) à 63 chiffres binaires (étendus), ce qui offre une précision de 7 à 8 pour les chiffres décimaux simples et de 19 à 20 pour les chiffres décimaux étendus. Le point décimal (virgule) est implicite avant le chiffre gauche (le plus significatif) de la mantisse, mais lorsqu'on opère sur un nombre, sa position est décalée vers la gauche ou la droite conformément à l'ordre binaire du nombre stocké dans la partie exponentielle , c'est pourquoi les opérations sur les nombres réels sont appelées arithmétique à virgule flottante (virgule).

Les types Single, Double et Extended sont accessibles uniquement dans des modes de compilation spéciaux. Pour activer ces modes, sélectionnez l'élément de menu Possibilités, Compilateur… et activez l'option 8087/80287 en groupe Traitement numérique.

Une position particulière dans Turbo Pascal est occupée par le type Comp, qui est traité comme un nombre réel sans parties exponentielles ni fractionnaires. En fait, Comp est un grand entier signé qui stocke 19 à 20 chiffres décimaux significatifs. En même temps, dans les expressions, Comp est entièrement compatible avec tout autre type réel : toutes les opérations réelles y sont définies, il peut être utilisé comme argument pour des opérations mathématiques, etc.

Les nombres réels sont spécifiés dans le système de nombres décimaux dans l'un des deux formes.

DANS forme à virgule fixe l'enregistrement est constitué d'un nombre entier et d'une partie fractionnaire, séparés l'un de l'autre par un point, par exemple :

0.087 4.0 23.5 0.6

DANS forme à virgule flottante l'entrée contient la lettre E, qui signifie « multiplier par dix à la puissance », et la puissance est un entier, par exemple :

7E3 6,9E-8 0,98E-02 45E+04

Les opérations suivantes sont définies sur les objets de type réel : +, -, *, /.

Les opérations "*" et "/" ont une priorité plus élevée que les opérations "+" et "-".

Si au moins un opérande est réel, alors les opérations +, -, *, / conduisent à un résultat réel. L'opération de division / conduit à un résultat réel même dans le cas de deux opérandes entiers, par exemple : 9/3 = 3,0.

Pour travailler avec des données réelles, des fonctions mathématiques standard présentées dans le tableau peuvent être utilisées. 9. Le résultat de ces fonctions est également réel.

Tableau 9

Fonctions mathématiques qui fonctionnent avec des données réelles

Il est interdit d'utiliser des variables et constantes de type REAL :

– dans les fonctions pred(x), succ(x), ord(x) ;

– comme index de tableau ;

– comme étiquettes dans les déclarations de transfert de contrôle ;

– comme variables de contrôle (paramètres de cycle).

Pour convertir un nombre réel en entier, vous pouvez utiliser les fonctions suivantes :

trunc(x) – partie entière de x (x – réel) ;

round(x) – arrondi à l’entier le plus proche (x est réel).

Type de caractère. Les variables de caractères sont décrites à l'aide du mot réservé char :

Les valeurs de ce type sont sélectionnées dans un jeu de caractères ordonné (jeu ASCII) composé de 256 caractères. Chaque caractère se voit attribuer un entier compris entre 0 et 255. Par exemple, les lettres majuscules de l'alphabet latin A..Z ont les codes 65..90 et les lettres minuscules ont les codes 97..122.

La valeur d'une variable de type caractère est un caractère unique entouré d'apostrophes, par exemple :

'F' '8' '*'

Les variables de caractères peuvent être comparées entre elles et les codes de caractères sont comparés.

Il existe des fonctions qui établissent une correspondance entre un symbole et son code :

ord(c) – donne le numéro du symbole c ;

chr(i) – renvoie le numéro de caractère i.

Ces fonctions sont inverses les unes des autres.

Type booléen. Les variables booléennes sont décrites à l'aide du mot réservé boolean :

p1, p2 : booléen ;

Les variables de type booléen prennent deux valeurs : vrai(vrai), FAUX(mensonge).

Ces valeurs sont ordonnées comme suit : faux< true. false имеет порядковый номер 0, true имеет порядковый номер 1.

Les variables booléennes peuvent soit recevoir une valeur directement, soit utiliser une expression booléenne. Par exemple,

a, d, g, b : booléen ;

Opérations relationnelles (<, <=, >, >=, =, <>), appliqués à des variables entières, réelles et symboliques, produisent un résultat logique.

Les opérations logiques sur les opérandes de type logique produisent également un résultat logique (les opérations sont classées par ordre décroissant de priorité) (pour plus de détails, voir les tableaux 3 et 5) :

non – négation (opération NON);

et – multiplication logique (opération ET);

ou – addition logique (opération OU);

xor – OU exclusif.

L'expression (pas a) a le sens opposé de a.

L'expression (a et b) est évaluée comme vraie si seuls a et b sont vrais ; sinon, la valeur de cette expression est fausse.

L’expression (a ou b) est évaluée comme fausse si seulement a et b sont évalués comme faux ; sinon, le résultat est vrai.

Type d'énumération. Un type d'énumération non standard est spécifié par une énumération sous forme de noms de valeurs que peut prendre une variable. Chaque valeur est nommée par un identifiant et se trouve dans une liste entourée de parenthèses. Forme générale de description du type énuméré :

x = (w1, w2, …, wn);

où x est le nom du type, w1, w2,..., wn sont les valeurs que peut prendre une variable de type x.

Ces valeurs sont ordonnées w1

Les fonctions standard suivantes s'appliquent à l'argument w d'un type énuméré :

succ(w), pred(w), ord(w).

couleur=(rouge, noir, jaune, vert)

ww=(gauche, haut, droite, bas) ;

f : tableau de ww ;

succ(d) = jaune;

Les variables a et b sont de type w. ils peuvent prendre l'une des trois valeurs suivantes, avec

Les opérations relationnelles sont applicables aux valeurs de type énuméré : =,<>, <=, >=, <, >.

Il est permis de spécifier des constantes de type énumérées directement dans la section var sans utiliser de partition taper, Par exemple

c,d : (rouge, noir, jaune, vert) ;

Type de portée (limitée). Lors de la définition d'un type limité, vous spécifiez les valeurs initiales et finales que peut prendre une variable de type plage. Les valeurs sont séparées par deux points.

La description de type restreinte est de la forme

Ici a est le nom du type, min, max sont des constantes.

Lors de la spécification d'un type restreint, les règles suivantes doivent être respectées :

– les deux constantes limites min et max doivent être du même type ;

– un type limité est créé à partir des données d'un type de base, qui peut être un type entier, caractère ou énuméré. Par exemple:

col = rouge.. jaune;

lettre = 'a'..'f';

– Les variables d'un type restreint peuvent être déclarées dans la section var sans faire référence à la section type :

– un type restreint hérite de toutes les propriétés du type de base à partir duquel il est créé ;

– la limite minimale doit toujours être inférieure à la limite maximale.

Tableaux. Un tableau est un type complexe qui est une structure composée d'un nombre fixe de composants du même type. Le type de composant est appelé type de base. Tous les composants de la baie peuvent être facilement commandés et l'accès à chacun d'entre eux peut être fourni en indiquant simplement son numéro de série. Description du tableau dans la section var a la forme :

un: tableau de t2 ;

où a est le nom du tableau, tableau, de– mots de service (signifiant « tableau de… »), t1 – type d'index ; t2 – type de composant (type de base).

Le nombre d'index détermine la taille du tableau. Les index peuvent être de type entier (sauf entier long), caractère, logique, énumération et plage. Les indices sont séparés par des virgules et placés entre crochets. Les composants du tableau peuvent être de n’importe quel type, à l’exception du fichier.

Exemple 1. Considérons un tableau unidimensionnel C dont les valeurs sont cinq nombres réels :

4.6 6.23 12 -4.8 0.7

La description de ce tableau est la suivante :

c : tableau de réels ;

En fonction d'une valeur d'index spécifique, vous pouvez sélectionner un composant de tableau spécifique (par exemple, C signifie le troisième élément du tableau C, c'est-à-dire le nombre 12).

Exemple 2. Considérons un tableau bidimensionnel B (matrice B), dont la valeur est un tableau d'entiers :

La description de ce tableau est la suivante :

b d'un nombre entier ;

Ici b est le nom du tableau, le premier index est le numéro de ligne et prend les valeurs de 1 à 2, le second est le numéro de colonne et prend les valeurs de 1 à 4. En fonction des valeurs d'index spécifiques, vous pouvez sélectionnez un composant de tableau spécifique (par exemple, b signifie un élément de tableau situé dans la première ligne et la troisième colonne, c'est-à-dire le numéro -4).

Les index peuvent être des expressions arbitraires correspondant au type d'index issu de la description du tableau :

a : tableau de réels ;

une[(i+1)*2] := 24;

L'ensemble des opérations sur les éléments du tableau est entièrement déterminé par le type de ces éléments.

Type de chaîne. Le type chaîne est un ensemble de chaînes de caractères de longueur arbitraire (de zéro à un nombre donné). Les variables de type chaîne sont décrites à l'aide d'un mot fonction chaîne:

B : chaîne ;

Particularités :

– la valeur d'une variable chaîne peut être saisie à l'aide du clavier, affectée dans un opérateur d'affectation ou lue à partir d'un fichier. Dans ce cas, la longueur de la chaîne saisie peut être quelconque (inférieure à la taille spécifiée, égale à la taille ou supérieure, dans ce dernier cas, les caractères supplémentaires sont supprimés) ; a:= « Résultats » ;

– il est permis d'utiliser l'opération de concaténation dans l'opérateur d'affectation, puisque les chaînes peuvent changer dynamiquement leur longueur : a:= a + « calculs » ;

– la longueur maximale d'une variable chaîne est de 255 caractères, cette indication de longueur peut être omise :

un: chaîne;

a1 : chaîne ;

Les variables a et a1 sont les mêmes (description équivalente).

– la mémoire pour les variables de type chaîne est allouée au maximum, mais seule la partie de la mémoire actuellement occupée par les caractères chaîne est utilisée. Pour décrire une variable chaîne de longueur n, n+1 octets de mémoire sont utilisés : n octets pour stocker les caractères de chaîne, n+1 octets pour stocker la longueur actuelle.

– les opérations de comparaison sont définies sur des valeurs de types chaînes :< <= > >= = <>. Une chaîne courte est toujours plus petite qu’une longue. Si les chaînes ont la même longueur, les codes de caractères sont comparés.

– l'accès aux éléments individuels d'une chaîne est possible de la même manière que l'accès aux éléments d'un tableau : a, a. Le numéro de l'élément de ligne est indiqué entre crochets.

Procédures et fonctions orientées vers le travail avec des chaînes.

concaténer (s1, s2,…)– fonction de fusion de chaînes, s1, s2,... - lignes, le nombre de lignes peut être arbitraire. Le résultat de la fonction est une chaîne. Si la chaîne résultante comporte plus de 255 caractères, la chaîne est tronquée à 255 caractères.

copie(s, index, nombre)– fonction d'extraction d'une chaîne d'une chaîne source s longueur compter caractères, commençant par le numéro du caractère indice.

supprimer (s, index, nombre)– procédure pour supprimer de la chaîne s une sous-chaîne de longueur compter caractères, commençant par le numéro du caractère indice.

insérer (s1, s2, index)– procédure d'insertion de ligne s1à la ligne s2, en commençant par le caractère avec le numéro indice.

longueur(s)– fonction pour déterminer la longueur actuelle de la chaîne, renvoie un nombre égal à la longueur actuelle de la chaîne.

pos(s1, s2)– fonction de recherche dans une chaîne s2 sous-chaînes s1. renvoie le numéro de position du premier caractère d'une sous-chaîne s1 en ligne s2(ou 0 si cette ligne n'existe pas).

val (st, x, code)– procédure de conversion de chaînes en variable entière ou réelle X. Paramètre code contient 0 si la conversion a réussi (et en X le résultat de la conversion est placé), ou le numéro de position de la ligne où le caractère erroné est détecté (dans ce cas, la valeur X ne change pas).

Compatibilité et conversion de type. Turbo Pascal est un langage typé. Il est construit sur la base du strict respect du concept de type, selon lequel toutes les opérations utilisées dans le langage sont définies uniquement sur des opérandes de types compatibles.

Deux types sont considérés comme compatibles si :

– les deux sont du même type ;

– les deux sont réels ;

- les deux sont intacts ;

– un type est un type de plage du deuxième type ;

– les deux sont des types de plage du même type de base ;

– les deux sont des ensembles composés d'éléments du même type de base ;

– les deux sont des chaînes condensées (définies avec le mot précédent condensé) de même longueur maximale;

– l'un est un type chaîne et l'autre est un type chaîne ou caractère ;

– un type est n'importe quel pointeur et l'autre est un pointeur vers son objet associé ;

– les deux sont des types procéduraux avec le même type de résultat (pour un type de fonction), le même nombre de paramètres et le même type de paramètres correspondant mutuellement.

La compatibilité des types est particulièrement importante dans les opérateurs d’affectation. Soit t1 le type de la variable et t2 le type de l'expression, c'est-à-dire que l'affectation t1:=t2 est effectuée. Cette affectation est possible dans les cas suivants :

– t1 et t2 sont du même type, et ce type ne fait pas référence aux fichiers, aux tableaux de fichiers, aux enregistrements contenant des champs de fichier ou aux tableaux de tels enregistrements ;

– t1 et t2 sont des types ordinaux compatibles, et la valeur de t2 se situe dans la plage des valeurs possibles de t1 ;

– t1 et t2 sont des types réels, et la valeur de t2 se situe dans la plage des valeurs possibles de t1 ;

– t1 – type réel et t2 – type entier ;

– t1 – ligne et t2 – caractère ;

– t1 – chaîne et t2 – chaîne compressée ;

– t1 et t2 – chaînes compressées compatibles ;

– t1 et t2 sont des ensembles compatibles et tous les membres de t2 appartiennent à l'ensemble des valeurs possibles de t1 ;

– t1 et t2 sont des pointeurs compatibles ;

– t1 et t2 sont des types procéduraux compatibles;

– t1 est un objet et t2 est son descendant.

Dans un programme, les données d'un type peuvent être converties en données d'un autre type. Cette conversion peut être explicite ou implicite.

La conversion de type explicite appelle des fonctions de conversion spéciales dont les arguments appartiennent à un type et dont les valeurs appartiennent à un autre. Un exemple est les fonctions déjà évoquées ord, trunc, round, chr.

La conversion implicite n'est possible que dans deux cas :

– dans les expressions composées de variables réelles et entières, ces dernières sont automatiquement converties en un type réel, et l'expression entière dans son ensemble acquiert un type réel ;

– une même zone mémoire est alternativement traitée comme contenant des données d'un type ou d'un autre (combinant des données de types différents en mémoire).

Pour qu'une machine puisse traiter des données d'entrée, elle doit « comprendre » à quel type appartiennent les variables dans lesquelles les valeurs sont stockées. En l'absence d'informations sur le format des données, l'ordinateur ne sera pas en mesure de déterminer si telle ou telle opération est autorisée dans un cas particulier : par exemple, il est intuitivement clair qu'il est impossible d'élever une lettre à une puissance ou de prendre l'intégrale d'une chaîne. Ainsi, l'utilisateur doit déterminer quelles actions peuvent être effectuées avec chaque variable.

Comme dans d'autres langages de programmation de haut niveau, les types de variables en Pascal sont optimisés pour effectuer des tâches de différents types, ont une plage de valeurs et une longueur en octets différentes.

Subdivision des types de variables

Les types de variables en Pascal sont divisés en simples et structurés. Les types simples incluent les types réels et ordinaux. Les structurés incluent des tableaux, des enregistrements, des ensembles et des fichiers. Séparément, les pointeurs, les objets et les types procéduraux sont distingués.

Regardons les types ordinaux et réels. Les types ordinaux incluent 5 types entiers, le type énumération et le type plage.

Types ordinaux

Il existe 5 types d'entiers, différant par la longueur d'octet et la plage de valeurs.

La longueur de Byte et ShortInt est de 1 octet. La différence entre eux est que Byte ne stocke que les valeurs non négatives, tandis que ShortInt vous permet de stocker les valeurs négatives (de -128 à +127). Les types Word et Integer sont liés les uns aux autres de la même manière, la seule différence étant que leur taille est de 2 octets.

Enfin, LongInt vous permet de stocker des valeurs négatives et positives en utilisant 4 octets - à la puissance 16 de la dimension numérique de chaque côté de zéro. Différents types de variables en Pascal contribuent à la solution efficace des tâches utilisateur, car dans chaque cas spécifique, une plage de valeurs petite et large peut être requise, et il peut également y avoir des restrictions sur la quantité de mémoire allouée.

Il est important de comprendre que zéro occupe autant d’espace mémoire que n’importe quel autre nombre. Ainsi, lors de la formation d'une plage de valeurs, le nombre négatif minimum en valeur absolue sera supérieur d'un nombre positif : par exemple, de -128 à +127.

Les variables appartenant à peuvent prendre la valeur TRUE (vrai) ou FALSE (faux) et nécessitent 1 octet de mémoire.

Le type CHAR vous permet de stocker l'un des nombreux caractères qui existent dans la mémoire de l'ordinateur. Parallèlement, dans les variables symboliques en Pascal, seul le code du signe est effectivement stocké, selon lequel sa forme graphique est affichée.

Types réels

Parmi les types de variables en Pascal, il en existe plusieurs numériques avec la possibilité d'écrire une partie fractionnaire. Les différences entre les types Single, Real, Double et Extended se résument à la plage de valeurs acceptées, au nombre de chiffres significatifs après la virgule décimale et à la taille en octets.

Selon l'ordre présenté ci-dessus, une variable de chaque type occupera 4, 6, 8 ou 10 octets.

Tableaux

Les types de données structurées sont complexes et vous permettent de combiner un certain nombre de valeurs simples au sein d'une seule variable. Un bon exemple est un tableau, qui peut être défini comme suit :

String=tableau de caractères ;

Ainsi, nous avons obtenu un type appelé String, qui nous permet de définir des variables jusqu'à 100 caractères. La dernière ligne spécifie directement un tableau unidimensionnel Y de type String. Les variables en Pascal sont décrites en plaçant l'identifiant à gauche et la valeur de la variable à droite, après le signe égal.

La plage d'index écrite permet d'accéder à chaque élément spécifique du tableau :

Dans ce cas, on lit le deuxième élément du tableau Y précédemment créé.

Les variables chaîne en Pascal sont également un cas particulier de tableau unidimensionnel, car une chaîne est une séquence de caractères, c'est-à-dire des éléments de type char.

Des postes

Un enregistrement est constitué de plusieurs champs remplis de données de tout type sauf fichier. En général, ce type de variable s'apparente à un élément de base de données. Par exemple, vous pouvez saisir le nom et le numéro de téléphone d’une personne :

tapez NTel = Enregistrer

La première ligne à gauche indique le nom du type et à droite, l'enregistrement du mot de service. La deuxième ligne contient un champ avec un nom, la troisième un numéro de téléphone. Le mot « fin » signifie que nous avons renseigné tous les champs souhaités, ce qui termine le processus de création d'un enregistrement.

Enfin, dans la dernière ligne, nous définissons la variable One, qui est de type NTel.

Vous pouvez accéder à la fois à l'enregistrement dans son ensemble et à ses composants individuels, par exemple : one.NAME (c'est-à-dire nom_variable. nom_champ_enregistrement).

Des dossiers

Pascal vous permet de travailler avec des fichiers texte, typés et non typés, qui sont une séquence structurée de composants ayant le même type.

Lors de la lecture ou de l'écriture dans un fichier, l'adresse complète ou sa forme abrégée peut être utilisée :

'C:\Dossier\File2.txt'

La forme courte est utilisée lorsque le fichier est placé dans le dossier où est stocké le programme qui y accède. Le formulaire complet peut être utilisé en toute circonstance.

Vous pouvez définir une variable de type de fichier comme suit :

f1 : fichier d'entier ;

Pour travailler avec des fichiers, diverses fonctions et procédures sont utilisées qui associent une variable à un fichier sur le disque, l'ouvrent en lecture, écriture et écrasement, la ferment une fois terminé, vous permettant de créer un nouveau nom et de supprimer le fichier de l'ordinateur.

Enfin

Sans la possibilité d'utiliser différents types de variables en Pascal, l'utilisateur ne pourra pas implémenter même la tâche la plus simple. Pour que le programme exécute l'algorithme sans erreurs, il est nécessaire d'apprendre à la fois les mots de fonction et la syntaxe, car la machine ne peut « comprendre » les commandes que si elles sont écrites de la seule manière correcte.