Quels types de variables sont utilisés en Pascal. Types de données en Pascal (variables, constantes), leurs types et description
Les types ordinaux incluent (voir Figure 4.1) les types entier, logique, caractère, énuméré et plage. La fonction ORD(X) est applicable à n'importe lequel d'entre eux, qui renvoie le numéro ordinal de la valeur de l'expression X. Pour les types entiers, la fonction ORD(X) renvoie la valeur de X lui-même, c'est-à-dire ORD(X) = X pour X appartenant à n’importe quel type de shell. L’application de ORD(X) aux types booléen, caractère et énumération produit un entier positif compris entre 0 et 1 (booléen), 0 à 155 (caractère), 0 à 65 535 (énumération). Un type plage conserve toutes les propriétés du type ordinal sous-jacent, donc le résultat de l’application de la fonction ORD(X) dépend des propriétés de ce type.
Vous pouvez également appliquer des fonctions aux types ordinaux :
PRED (X) - renvoie la valeur précédente du type ordinal (la valeur qui correspond au nombre ordinal ORD(X) - 1), c'est-à-dire
ORD(PRED(X)) = ORD(X) - 1;
SUCC (X) - renvoie la valeur ordinale suivante qui correspond au nombre ordinal ORD(X) +1, c'est-à-dire
ORD(SUCC(X)) = ORD(X) + 1.
Par exemple, si un programme définit une variable
alors la fonction PRED(C) renverra la valeur « 4 » et la fonction SUCC(C) renverra la valeur « 6 ».
Si nous imaginons n'importe quel type ordinal comme un ensemble ordonné de valeurs, augmentant de gauche à droite et occupant un certain segment sur l'axe des nombres, alors la fonction PRED(X) n'est pas définie pour la gauche, et SUCC(X) pour la droite. fin de ce segment.
Des types entiers. La plage des valeurs possibles des types entiers dépend de leur représentation interne, qui peut être un, deux ou quatre octets. Dans le tableau 4.1 montre le nom des types entiers, la longueur de leur représentation interne en octets et la plage de valeurs possibles.
Tableau 4.1
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ù WORD peut être utilisé, BYTE peut être utilisé (mais pas l'inverse), LONGINT "inclut" INTEGER, qui, à son tour, inclut SHORTINT.
La liste des procédures et fonctions applicables aux types entiers est donnée dans le tableau 4.2. Des lettres b, s, w, je, l les expressions de type BYTE, SHORTINT, WORD, INTEGER et LONGINT sont désignées, respectivement, x est une expression de l'un de ces types ; des lettres vb, contre, vw, vi, vl, vx désignent les variables des types correspondants. Un paramètre facultatif est indiqué entre crochets.
Tableau 4.2
| 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[, je]) | - | 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 (w) | Même | Même |
| Lo(je) | " | Renvoie l'octet de poids faible de l'argument |
| Faible) | " | Même |
| impair(l) | Booléen | Renvoie True 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-l) |
| sgr(x) | X | Renvoie le carré de l'argument |
| échanger(i) | Entier | Échange des octets dans un mot |
| échanger(w) | Mot |
Lorsqu'on opère avec des entiers, le type du résultat correspondra au type des opérandes, et si les opérandes sont de types entiers différents, au type de l'opérande qui a la puissance maximale (plage maximale de valeurs). Un éventuel débordement du résultat n'est en aucun cas contrôlé, ce qui peut conduire à des malentendus, par exemple :
une := 32 767 ; (Valeur ENTIÈRE maximale possible)
x := une + 2 ; (Débordement lors de l'évaluation de cette expression !}
y:= LongInt(a)+2; (Pas de débordement après avoir converti la variable en un type plus puissant)
ÉcrireLn(x:10:0, y:10:0)
À la suite de l'exécution du programme, nous obtenons
Type booléen. Les valeurs booléennes peuvent être l'une des constantes pré-déclarées FALSE ou TRUE. Les règles s'appliquent à eux :
FAUX< True;
succ(Faux)= Vrai ;
pred(Vrai) = Faux.
Puisque le type booléen est un type ordinal, il peut être utilisé dans un opérateur de type dénombrable, par exemple :
pour 1 : = Faux à Vrai, faites ....
Type de caractère. La valeur d'un type de caractère est l'ensemble de tous les caractères PC. Chaque caractère se voit attribuer un entier compris entre 0 et 255. Ce numéro sert de code pour la représentation interne du symbole ; il est renvoyé par la fonction ORD.
Le code ASCII est utilisé pour l'encodage ( Code américain normalisé pour l'échange d'information- Code américain normalisé pour l'échange d'information). Il s'agit d'un code de 7 bits, c'est-à-dire il ne peut encoder que 128 caractères dans la plage de 0 à 127. Dans le même temps, dans l'octet de 8 bits alloué au stockage d'un caractère dans Turbo Pascal, vous pouvez encoder deux fois plus de caractères dans la plage de 0 à 255. Le la première moitié des caractères PC avec les codes 0...127 correspond à la norme ASCII (Tableau 4.3). La seconde moitié des caractères avec les codes 128...255 ne sont pas limitées par le cadre rigide de la norme et peuvent être modifiées sur différents types de PC (l'annexe 2 montre quelques options de codage courantes pour ces caractères).
Tableau 4.3
| Codage des caractères selon la norme ASCII | |||||||
| Code | Symbole | Code | Symbole | Code | Symbole | Code | Symbole |
| NUL | B.L. | ® | " | ||||
| ZON | ! | UN | un | ||||
| STX | " | DANS | b | ||||
| ETX | # | AVEC | Avec | ||||
| EOT | $ | D | d | ||||
| ENQ | % | E | e | ||||
| DEMANDER | & | F | F | ||||
| BEL | " | g | g | ||||
| BS. | ( | H | h | ||||
| NT | ) | je | je | ||||
| LF | * | J. | j | ||||
| Vermont | + | k | k | ||||
| FR | , | L | je | ||||
| CR | - | M | m | ||||
| DONC | . | N | n | ||||
| SI. | / | À PROPOS | |||||
| DEL | p | P. | |||||
| DC1 | Q | q | |||||
| DC2 | R. | r | |||||
| DC3 | S | s | |||||
| DC4 | T | t | |||||
| N.A.K. | U | toi | |||||
| SYN | V | V | |||||
| ETB | w | w | |||||
| PEUT | X | X | |||||
| E.M. | U | U | |||||
| SOUS | : | z | z | ||||
| ÉCHAP | / | [ | { | ||||
| FS | < | \ | je | ||||
| G.S. | = | ] | } | ||||
| R.S. | > | ^ | ~ | ||||
| NOUS | ? | - | n |
Les caractères avec les codes 0...31 font référence aux codes de service. Si ces codes sont utilisés dans le texte des caractères du programme, ils sont considérés comme des espaces. Lorsqu'ils sont utilisés dans des opérations d'E/S, ils peuvent avoir la signification indépendante suivante :
| Symbole | Code | Signification |
| BEL | Appel; L'affichage de ce symbole est accompagné d'un signal sonore | |
| NT | Tabulation horizontale ; lorsqu'il est affiché à l'écran, déplace le curseur vers une position qui est un multiple de 8 plus 1 (9, 17, 25, etc.) | |
| LF | Traduction de ligne ; lors de son affichage à l'écran, tous les caractères suivants seront affichés à partir de la même position, mais sur la ligne suivante | |
| Vermont | Onglet vertical ; lorsqu'il est affiché à l'écran, il est remplacé par un caractère spécial | |
| FR | Exécution de la page ; lors de la sortie sur une imprimante, il forme une page ; lors de la sortie à l'écran, il est remplacé par un caractère spécial ; | |
| CR | Retour en calèche ; saisi en appuyant sur la touche Entrée (lors de la saisie avec READ ou READLN, cela signifie la commande « Entrée » et n'est pas placé dans le tampon d'entrée ; en sortie, cela signifie la commande « Continuer la sortie depuis le début de la ligne actuelle ») | |
| SOUS | Fin de fichier; saisi à partir du clavier en appuyant sur Ctrl-Z ; lors de la sortie, il est remplacé par un signe spécial | |
| CSS | Fin du travail; saisie à partir du clavier en appuyant sur la touche ESC ; lors de la sortie, il est remplacé par un signe spécial |
Les opérations relationnelles, ainsi que les fonctions intégrées, sont applicables au type CHAR : СНR(В) - fonction du type CHAR ; convertit une expression B de type BYTE en caractère et la renvoie avec sa valeur ;
UPCASE(CH) - Fonction de type CHAR ; renvoie la lettre majuscule si CH est une lettre latine minuscule, sinon renvoie le caractère CH lui-même, par exemple :
cl:= UpCase("s") ;
c2:= UpCase ("Ф") ;
ÉcrireLn(cl," ",c2)
Puisque la fonction UPCASE ne traite pas le cyrillique, le résultat de l'exécution de cette commande
les programmes seront affichés à l'écran
Type d'énumération. 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, par exemple :
couleurs =(rouge, blanc, bleu) ;
L'utilisation de types énumérés rend les programmes plus visuels. Si, par exemple, le programme utilise des données associées aux mois de l'année, alors le fragment suivant du programme :
TypeMonth=(janvier, février, mars, avril, mai, juin, juillet, août, septembre, octobre, novembre, décembre) ;
mois : TypeMois ;
si mois = Août alors WriteLn("Ce serait bien d'aller à la mer !");
Ce serait, voyez-vous, très clair. Hélas! En Turbo Pascal vous ne pouvez pas utiliser le cyrillique dans les identifiants, nous sommes donc obligés d'écrire ainsi :
TypeMonth=(jan, février, mars, mai, juin, juillet, août, septembre, octobre, nov, décembre) ;
mois : TypeMois ;
ifmonth = août then WriteLn("Ce serait bien d'aller à la mer !");
La correspondance entre les valeurs d'un type énuméré et les nombres ordinaux de ces valeurs est établie par l'ordre d'énumération : la première valeur de la liste reçoit le nombre ordinal 0, la seconde - 1, etc. La capacité maximale d'un type énuméré est de 65 536 valeurs, donc en fait un type énuméré définit un certain sous-ensemble du type WORD entier et peut être considéré comme une déclaration compacte d'un groupe de constantes entières avec des valeurs 0, 1, etc.
L'utilisation de types énumérés augmente la fiabilité des programmes en vous permettant de contrôler les valeurs que reçoivent les variables correspondantes. Par exemple, donnons les types énumérés suivants :
couleurs = (noir, rouge, blanc) ;
ordinal= (un, deux, trois) ;
jours = (lundi, mardi, mercredi) ;
En termes de pouvoir et de représentation interne, les trois types sont équivalents :
ord(noir)=0, ..., ord(blanc)=2,
ord(un)=0, ...ord(trois)=2,
ord(lundi)=0, ...ord(mercredi)=2.
Cependant, si les variables sont définies
col:couleurs; num:ordénal;
alors les opérateurs sont autorisés
num:= succ(deux);
jour:= pred(mardi);
mais inacceptable
Comme déjà mentionné, il existe une correspondance biunivoque entre les valeurs d'un type énuméré et l'ensemble d'entiers spécifié par la fonction ORD(X). Turbo Pascal permet également la conversion inverse : toute expression de type WORD peut être convertie en une valeur de type énumération, tant que la valeur de l'expression entière ne dépasse pas la puissance1™ du type énumération. Cette conversion est réalisée en utilisant une fonction déclarée automatiquement avec le nom du type énuméré (voir section 4.4). Par exemple, pour la déclaration de type évoquée ci-dessus, les affectations suivantes sont équivalentes :
col:= couleurs(0);
Bien sûr, la mission
sera inacceptable.
Les variables de n'importe quel type énuméré peuvent être déclarées sans déclarer au préalable ce type, par exemple :
col : (noir, blanc, vert) ;
Gamme de types. Un type plage est un sous-ensemble de son type de base, qui peut être n’importe quel type ordinal à l’exception d’un type plage. Un type de plage est défini par les limites de ses valeurs au sein du type de base :
<мин.знач.>..<макс.знач.>
Ici<мин.знач. >- valeur minimale de la plage de types ;
<макс.знач.>- sa valeur maximale.
Par exemple:
chiffre = "0".."9" ;
Le type range n'a pas besoin d'être décrit dans la section TYPE, mais peut être spécifié directement lors de la déclaration d'une variable, par exemple :
Ichr : "A".."Z" ;.
Lors de la détermination d'un type de plage, vous devez suivre les règles suivantes :
- 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. Un type range hérite de toutes les propriétés de son type de base, mais avec les limitations de sa puissance inférieure. En particulier, si une variable est définie
jours = (lu,tu,nous,je,fr,sa,su);
WeekEnd = sa .. su;
alors ORD(W) renverra la valeur 5 tandis que PRED(W) entraînera une erreur.
La bibliothèque standard Turbo Pascal comprend deux fonctions qui prennent en charge l'utilisation des types de plage :
HIGH(X) - renvoie la valeur maximale du type de plage auquel appartient la variable X ;
LOW(X) - renvoie la valeur minimale du type de plage.
Le programme court suivant imprimera la ligne
ÉcrireLn(Faible(k),"..",Élevé(k))
L'ensemble des nombres entiers est infini, mais nous pouvons toujours choisir le nombre de bits pour représenter tout entier qui apparaît lors de la résolution d'un problème spécifique. L'ensemble des nombres réels est non seulement infini, mais aussi continu, donc quel que soit le nombre de bits que nous prenons, nous rencontrerons inévitablement des nombres qui n'ont pas de représentation exacte. Les nombres à virgule flottante sont une façon possible de représenter des nombres réels, ce qui représente un compromis entre précision et plage de valeurs acceptées.
Un nombre à virgule flottante se compose d'un ensemble de chiffres individuels, classiquement divisés en signe, exposant et mantisse. L'exposant et la mantisse sont des nombres entiers qui, avec le signe, donnent la représentation suivante d'un nombre à virgule flottante :
Mathématiquement, cela s'écrit ainsi :
(-1) s × M × B E, où s est le signe, B est la base, E est l'exposant et M est la mantisse.
La base détermine le système de numérotation numérique. Il a été mathématiquement prouvé que les nombres à virgule flottante de base B=2 (représentation binaire) sont les plus résistants aux erreurs d'arrondi, donc en pratique, seules les bases 2 et, plus rarement, 10 sont rencontrées. Pour une présentation plus approfondie, nous supposerons toujours B=. 2, et la formule pour un nombre à virgule flottante ressemblera à :
(-1) s × M × 2 E
Qu'est-ce que la mantisse et l'ordre ? Mantisse est un entier de longueur fixe qui représente les bits les plus significatifs d'un nombre réel. Disons que notre mantisse se compose de trois bits (|M|=3). Prenons, par exemple, le nombre « 5 », qui dans le système binaire sera égal à 101 2. Le bit de poids fort correspond à 2 2 =4, le bit du milieu (qui est égal à zéro) est 2 1 =2 et le bit de poids faible est 2 0 =1. Commande– c'est le degré de la base (deux) du chiffre le plus élevé. Dans notre cas E=2. Il est pratique d'écrire de tels nombres sous la forme standard dite « scientifique », par exemple « 1,01e+2 ». Il est immédiatement clair que la mantisse est composée de trois signes et que l'ordre est de deux.
Disons que nous voulons obtenir un nombre fractionnaire en utilisant les mêmes 3 bits de la mantisse. Nous pouvons le faire si nous prenons, disons, E=1. Alors notre nombre sera égal
1,01e+1 = 1×2 1 +0×2 0 +1×2 -1 =2+0,5=2,5
Évidemment, le même nombre peut ainsi être représenté de différentes manières. Considérons un exemple avec la longueur de la mantisse |M|=4. Le chiffre « 2 » peut être représenté comme suit :
2 = 10 (en binaire) = 1,000e+1 = 0,100e+2 = 0,010e+3.
C'est pourquoi, dès les toutes premières machines, les nombres étaient représentés dans ce qu'on appelle forme normalisée, lorsque le premier bit de la mantisse était toujours supposé égal à un.
Cela enregistre un bit (puisque le bit implicite n'a pas besoin d'être stocké en mémoire) et garantit que le nombre est représenté de manière unique. Dans notre exemple, « 2 » a une seule représentation (« 1.000e+1 ») et la mantisse est stockée en mémoire sous la forme « 000 », car l’unité principale est implicitement implicite. Mais un nouveau problème se pose dans la représentation normalisée des nombres : il est impossible de représenter zéro sous cette forme.
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 valeursest 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 l'exemple de commentaires, 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
- évaluation des expressions entre parenthèses ;
- multiplication, division, div, mod de gauche à droite ;
- 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.
- 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 :
- 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.
- Opération d'exponentiation en Pascal manque en tant que tel. Mais pour élever un nombre à une puissance, vous pouvez utiliser la fonction exp.
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.
| une : =- 9 ; b:=abdos(a); (b=9) |
une :=-9 ; b:=abdos(a); (b=9)
Un exemple d'utilisation de la fonction impaire :
var x:entier; commencer x:=3; écrire(sqr(x)); (réponse 9) fin.
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.
La notion de données est l’une des clés de la programmation et de l’informatique en général. En gros, les données en informatique sont des informations qui sont en état de stockage, de traitement ou de transmission pendant une certaine période de temps. Dans les machines de Turing, l’information a un type, qui dépend à son tour du type d’information.
Les types de données en Pascal définissent les valeurs possibles des variables, constantes, expressions et fonctions. Ils sont intégrés et personnalisés. Les types intégrés sont initialement présents dans le langage de programmation et les types personnalisés sont créés par le programmeur.
Selon le mode de présentation et de traitement, les types de données sont :
- simple
- structuré
- pointeurs
- objets
- procédures
Cet article ne considérera que les types de données les plus simples, car aux premières étapes de la formation, il sera plus facile pour votre programme de se passer, par exemple, de fichiers et d'enregistrements que de variables entières ou de chaînes.
Type entier
Cela inclut plusieurs types entiers, qui diffèrent par la plage de valeurs, le nombre d'octets alloués pour les stocker et le mot avec lequel le type est déclaré.
| Taper | Gamme | Taille en octets |
| raccourci | -128…127 | 1 |
| entier | -32 768…32 767 | 2 |
| entier long | -2 147 483 648…2 147 483 647 | 4 |
| octet | 0…255 | 1 |
| mot | 0…65 535 | 2 |
Vous pouvez déclarer une variable entière dans la section Var, par exemple :
Toutes les opérations arithmétiques et logiques peuvent être effectuées sur les variables de cette catégorie à l'exception de la division (/), qui nécessite un type réel. Certaines fonctions et procédures standard peuvent également s'appliquer.
Type réel
En Pascal, il existe les types de données réels suivants :
| Taper | Gamme | Mémoire, octet | Nombre de chiffres |
| Réel | 2,9e-39 … 1,7e38 | 6 | 11-12 |
| Célibataire | 1,5e-45 … 3,4e38 | 4 | 7-8 |
| Double | 5.0e-324…1.7e308 | 8 | 15-16 |
| Étendu | 3.4e-4932 … 1.1e493 | 10 | 19-20 |
| Comp | -9.2e63…(9.2e63)-1 | 8 | 19-20 |
Plus d'opérations et de fonctions peuvent être effectuées sur eux que sur des entiers. Par exemple, ces fonctions renvoient un résultat réel :
péché(x) – sinus ;
cos(x) – cosinus ;
arctan(x) – arctangente ;
ln(x) – logarithme népérien ;
sqrt(x) – racine carrée ;
exp(x) – exposant ;
Type booléen
Une variable de type de données booléen ne peut prendre que deux valeurs : vrai et faux. Ici, vrai correspond à la valeur 1 et faux correspond à zéro. Vous pouvez déclarer une variable booléenne comme ceci :
Des opérations de comparaison et logiques peuvent être effectuées sur des données de ce type : not, et, ou, xor.
Type de caractère
Un type de données caractère est une collection de caractères utilisés dans un ordinateur particulier. Une variable de ce type prend la valeur d'un de ces caractères et occupe 1 octet en mémoire de l'ordinateur. Mot Carboniser définit une valeur de ce type. Il existe plusieurs manières d'écrire une variable (ou constante) caractère :
- comme un seul caractère entouré d'apostrophes : « W », « V », « p » ;
- en précisant le code du caractère dont la valeur doit être comprise entre 0 et 255.
- en utilisant la construction ^K, où K est le code du caractère de contrôle. La valeur de K doit être supérieure de 64 au code du caractère de contrôle correspondant.
Les opérations relationnelles et les fonctions suivantes sont applicables aux valeurs d'un type de données caractère :
Succès(x)- renvoie le caractère suivant ;
Préd(x)- renvoie le caractère précédent ;
Commande(x)- renvoie la valeur du code du caractère ;
Chr(x)- renvoie la valeur d'un symbole par son code ;
UpCase(x)- convertit les lettres de l'intervalle 'a'..'z' en majuscules.
Pour travailler efficacement avec un type de caractère, je recommande d'utiliser .
Type de chaîne
Une chaîne en Pascal est une séquence de caractères entourée d'apostrophes et est désignée par le mot Chaîne. Le nombre de caractères (longueur de ligne) ne doit pas dépasser 255. Si la longueur de la ligne n'est pas précisée, elle sera automatiquement déterminée à 255 caractères. La forme générale d'une déclaration de variable chaîne ressemble à ceci :
Var<имя_переменной>:chaîne[<длина строки>];
Chaque caractère d'une ligne possède son propre index (numéro). L'index du premier octet est 0, mais il ne stocke pas le premier caractère, mais la longueur de la chaîne entière, ce qui signifie qu'une variable de ce type occupera 1 octet de plus que le nombre de variables qu'elle contient. Le numéro du premier caractère est 1, par exemple, si nous avons la chaîne S='stroka', alors S=s;. Dans l’une des leçons suivantes, le type de données chaîne sera abordé plus en détail.
Type de données énumérées
Un type de données énuméré représente un nombre limité d'identifiants. Ces identifiants sont mis entre parenthèses et séparés par des virgules.
Type Jour=(lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche) ;
La variable A ne peut prendre que les valeurs spécifiées dans la section Type. Vous pouvez également déclarer une variable de type énuméré dans la section Var :
Var A : (lundi, mardi) ;
Les opérations relationnelles sont applicables à ce type, et il est prédéterminé que lundi Lorsqu'il est nécessaire de spécifier une plage de valeurs, dans de telles situations, le type de données intervalle est utilisé. La construction utilisée pour la déclaration est m..n, Où m est la valeur minimale (initiale), et n– maximum (final) ; ici m et n sont des constantes, qui peuvent être de type entier, caractère, énumération ou booléen. Les valeurs de type intervalle peuvent être décrites à la fois dans la section types et dans la section description des variables. Forme générale: TAPER<имя_типа> = <мин. значение>..<макс. значение>; Agence fédérale pour l'éducation Essai "TYPES DE DONNÉES EN PASCAL" 1. Types de données Toutes les données, c'est-à-dire les constantes, variables, propriétés, valeurs de fonction ou expressions 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. De plus, le type détermine également le format de la représentation interne des données dans la mémoire du PC. En général, le langage Object Pascal se caractérise par une structure ramifiée de types de données (Fig. 1.1). Le langage fournit un mécanisme pour créer de nouveaux types, grâce auquel le nombre total de types utilisés dans un programme peut être aussi grand que souhaité. Les données traitées dans le programme sont divisées en variables, constantes et littéraux : Constantes
représentent des données dont les valeurs sont définies dans la section de déclaration constante et ne changent pas pendant l'exécution du programme. Variables
sont déclarées dans la section de déclaration des variables, mais contrairement aux constantes, elles reçoivent leurs valeurs lors de l'exécution du programme, et ces valeurs peuvent être modifiées. Les constantes et les variables peuvent être désignées par leur nom. Littéral
n'a pas d'identifiant et est représenté directement par la valeur dans le texte du programme. Taper définit l'ensemble des valeurs que les éléments de données peuvent prendre et l'ensemble des opérations autorisées sur eux. Ce chapitre et les quatre suivants fournissent des descriptions détaillées de chaque type.
1.1 Types simples Les types simples incluent les types ordinaux, réels et datetime. Types ordinaux diffèrent en ce que chacun d’eux a un nombre fini de valeurs possibles. Ces valeurs peuvent être ordonnées d'une certaine manière (d'où le nom des types) et, par conséquent, chacune d'elles peut être associée à un nombre entier - le nombre ordinal de la valeur. Types réels, à proprement parler, ont également un nombre fini de valeurs, qui est déterminé par le format de la représentation interne d'un nombre réel. Cependant, le nombre de valeurs possibles de types réels est si grand qu'il n'est pas possible d'associer un entier (son nombre) à chacune d'elles. Type date-heure conçu pour stocker la date et l’heure. En fait, il utilise le format réel à ces fins. 1.1.1 Types ordinaux Les types ordinaux incluent (voir Figure 1.1) les types entier, logique, caractère, énuméré et plage. La fonction Ord(x) peut être appliquée à n'importe lequel d'entre eux, qui renvoie le numéro ordinal de la valeur de l'expression X. Riz. 1.1 - Structure des types de données Pour entier types, la fonction ord(x) renvoie la valeur de x lui-même, c'est-à-dire Ord(X) = x pour x appartenant à n'importe quel entier taper. Application d'Ord(x) à logique
, symbolique et énumérable types donne un entier positif compris entre 0 et 1 ( type booléen), de 0 à 255 ( symbolique), de 0 à 65535 ( dénombrable). Gamme de types préserve toutes les propriétés du type ordinal de base, donc le résultat de l'application de la fonction ord(x) dépend des propriétés de ce type. Vous pouvez également appliquer des fonctions aux types ordinaux : préd(x)- renvoie la valeur précédente du type ordinal (la valeur qui correspond au nombre ordinal ord(x) -1, c'est-à-dire ord(pred(x)) = ord(x) - 1 ; succès(x)- renvoie la valeur suivante du type ordinal, qui correspond au nombre ordinal ord(x) +1, c'est-à-dire ord(Succ(x)) = ord(x) + 1. Par exemple, si un programme définit une variable alors la fonction PRED(c) renverra le caractère « 4 », et la fonction SUCC(c) renverra le caractère « 6 ». Si nous imaginons n'importe quel type ordinal comme un ensemble ordonné de valeurs augmentant de gauche à droite et occupant un certain segment sur l'axe des nombres, alors la fonction pred(x) n'est pas définie pour l'extrémité gauche, et succ (x) est non défini pour l'extrémité droite de ce segment. Types entiers
. La plage des valeurs possibles des types entiers dépend de leur représentation interne, qui peut être un, deux, quatre ou huit octets. Dans le tableau 1.1 montre les noms des types entiers, la longueur de leur représentation interne en octets et la plage de valeurs possibles. Tableau 1.1 - Types entiers Les types Mot Long Et Int64 ont été introduits pour la première fois dans la version 4, et les types Petitint Et Cardinal non disponible dans Delphi 1. Tapez entier pour cette version, il prend 2 octets et a une plage de valeurs allant de -32768 à +32767, c'est-à-dire la même chose que Petitint
. 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ù il peut être utilisé mot, autorisé à utiliser Octet(mais pas l'inverse), en Entier long"entre dans" Petitint, qui à son tour comprend Raccourci
. La liste des procédures et fonctions applicables aux types entiers est donnée dans le tableau. 1.2. Les lettres b, s, w, i, l désignent des expressions du type suivant : Octet
, Entier court, mot, entier et entier long
, x est une expression de l’un de ces types ; les lettres vb, vs, vw, vi, vl, vx désignent des variables des types correspondants. Un paramètre facultatif est indiqué entre crochets. Tableau 1.2 - Procédures et fonctions standards applicables aux types entiers Lorsque vous travaillez avec des entiers, le type du résultat correspondra au type des opérandes, et si les opérandes sont de types entiers différents, au type général qui inclut les deux opérandes. Par exemple, lorsque vous travaillez avec raccourci Et mot le type commun sera entier. Par défaut, le compilateur Delphi ne produit pas de code pour vérifier si une valeur est hors plage, ce qui peut conduire à des malentendus. Types booléens
. Les types logiques incluent Booléen, ByteBool, Bool, wordBool Et LongBool. En Pascal standard, seul le type est défini Booléen, d'autres types logiques sont introduits dans Object Pascal pour la compatibilité avec Windows : types Booléen Et OctetBool chacun occupe un octet, Booléen Et MotBool- 2 octets chacun, LongBool- 4 octets. Les valeurs booléennes peuvent être l'une des constantes pré-déclarées False ou True. Le type booléen étant un type ordinal, il peut être utilisé dans une instruction de boucle de type dénombrable. Dans Delphi 32 pour Booléen signification Ord (True) = +1, tandis que pour les autres types ( Bool, WordBool etc.) Ord(True) = -1, donc ces types d'opérateurs doivent être utilisés avec prudence ! Par exemple, pour la version Delphi 6, l'instruction exécutable showMessage(" --- ") dans la boucle suivante pour ne sera jamais exécuté : pour L : = Faux à Vrai, faites Voir le message("--); Si l'on remplace le paramètre de boucle type L dans l'exemple précédent par Booléen, la boucle s'exécutera et le message apparaîtra deux fois à l'écran. [Pour les versions 1 et 2 de Delphi ord (True) =+1 pour tout type booléen.] Type de caractère
. La valeur d'un type de caractère est l'ensemble de tous les caractères PC. Chaque caractère se voit attribuer un entier compris entre 0 et 255. Ce numéro sert de code pour la représentation interne du symbole ; il est renvoyé par la fonction ord. Pour l'encodage sous Windows, on utilise le code ANSI (du nom de l'American National Standard Institute, l'institut américain de normalisation qui a proposé ce code). La première moitié des caractères PC avec les codes 0... 127 correspond au tableau 1.3. La seconde moitié des caractères avec les codes 128...255 varie selon les polices. Les polices Windows standard Arial Cyr, Courier New Cyr et Times New Roman utilisent les 64 derniers codes (de 192 à 256) pour représenter les caractères cyrilliques (sans les lettres « ё » et « Ё ») : « A »... « Z » sont des valeurs codées 192..223, "a"... "i" - 224...255. Les symboles « Ё » et « е » ont respectivement les codes 168 et 184. Tableau 1.3 - Codage des caractères selon la norme ANSI Les caractères avec les codes 0...31 font référence aux codes de service. Si ces codes sont utilisés dans le texte des caractères du programme, ils sont considérés comme des espaces. Pour taper carboniser les opérations relationnelles sont applicables, ainsi que les fonctions intégrées : Caractère (c)- tapez la fonction carboniser; convertit une expression en type Octet dans un symbole et le renvoie avec sa valeur ; UpCase(CH)- tapez la fonction carboniser; renvoie une lettre majuscule si сн est une lettre latine minuscule, sinon renvoie le symbole сн lui-même (pour le cyrillique, il renvoie le caractère original). Type d'énumération
. 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, par exemple : couleurs = (rouge, blanc, bleu) ; L'utilisation de types énumérés rend les programmes plus visuels. La correspondance entre les valeurs d'un type énuméré et les nombres ordinaux de ces valeurs est établie par l'ordre d'énumération : la première valeur de la liste reçoit le nombre ordinal 0, la seconde - 1, etc. La capacité maximale de un type énuméré contient 65 536 valeurs, donc en fait le type énuméré spécifie un sous-ensemble du type entier mot et peut être considéré comme une déclaration compacte d'un groupe de constantes entières avec des valeurs 0, 1, etc. L'utilisation de types énumérés augmente la fiabilité des programmes en vous permettant de contrôler les valeurs que reçoivent les variables correspondantes. Object Pascal permet la conversion inverse : toute expression de type Mot peut être converti en une valeur d'un type énuméré à moins que la valeur de l'expression entière ne dépasse la cardinalité de ce type. Cette conversion est réalisée en utilisant une fonction déclarée automatiquement avec le nom du type énuméré. Gamme de types
. Un type plage est un sous-ensemble de son type de base, qui peut être n’importe quel type ordinal à l’exception d’un type plage. Un type de plage est défini par les limites de ses valeurs au sein du type de base : <мин.знач.>..<макс.знач.> Ici<мин. знач. >- valeur minimale de la plage de types ;<макс. знач. >- sa valeur maximale. Le type de plage n'a pas besoin d'être décrit dans la section type, mais peut être spécifié directement lors de la déclaration de la variable. Lors de la détermination d'un type de plage, vous devez suivre les règles suivantes : 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. Un type range hérite de toutes les propriétés de son type de base, mais avec les limitations de sa puissance inférieure. En particulier, si une variable est définie. La bibliothèque standard Object Pascal comprend deux fonctions qui prennent en charge l'utilisation des types de plage : Élevé(x)- renvoie la valeur maximale du type de plage auquel appartient la variable x ; Faible(x)- renvoie la valeur minimale du type de plage. 1.1.2 Types réels Contrairement aux types ordinaux, dont les valeurs sont toujours mappées sur une série d'entiers et sont donc représentées de manière absolument précise dans PC, les valeurs des types réels définissent un nombre arbitraire uniquement avec une certaine précision finie en fonction du format interne du nombre réel. . Tableau 1.4 - Types réels Dans les versions précédentes de Delphi 1...3, tapez Réel occupait 6 octets et avait une plage de valeurs de 2,9*10-39 à 1,7*1038. Dans les versions 4 et 5, ce type est équivalent au type Double. Si nécessaire (pour des raisons de compatibilité), utilisez 6 octets Réel, vous devez spécifier une directive du compilateur (SREALCOMPATIBILITY ON). Comme le montre le tableau. 1.4, un nombre réel en Pascal Objet occupe de 4 à 10 octets contigus et a la structure suivante dans la mémoire du PC. Ici s est le chiffre du signe du nombre ; e - partie exponentielle ; contient un ordre binaire ; m est la mantisse du nombre. Mantisse m a une longueur de 23 (pour célibataire) jusqu'à 63 (pour Étendu) bits binaires, ce qui garantit une précision de 7...8 pour célibataire et 19...20 pour Étendu chiffres décimaux. 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). Notez que le coprocesseur arithmétique traite toujours les nombres au format Étendu, et les trois autres types réels dans ce cas sont obtenus en tronquant simplement les résultats à la taille requise et sont principalement utilisés pour économiser de la mémoire. Les types occupent une position particulière dans Object Pascal composition Et Devise, qui sont traités comme des nombres réels avec des parties fractionnaires d'une longueur fixe : en composition la partie fractionnaire a une longueur de 0 chiffre, c'est-à-dire qu'elle est simplement absente, dans devise la longueur de la partie fractionnaire est de 4 décimales. En fait, les deux types définissent un grand entier signé qui stocke 19 à 20 chiffres décimaux significatifs (en interne, ils occupent 8 octets contigus). En même temps, dans les expressions composition Et devise sont entièrement compatibles avec tout autre type réel : toutes les opérations réelles y sont définies, elles peuvent être utilisées comme arguments de fonctions mathématiques, etc. Le domaine d'application le plus approprié pour ces types est celui des calculs comptables. 1.1.3 Type date-heure Le type datetime est défini par un identifiant standard TDateHeure et est conçu pour stocker simultanément la date et l'heure. Dans la représentation interne, il occupe 8 octets et similaires devise est un nombre réel avec une partie fractionnaire fixe : la partie entière du nombre stocke la date et la partie fractionnaire stocke l'heure. La date est définie comme le nombre de jours écoulés depuis le 30 décembre 1899, et l'heure comme la fraction de jour écoulée depuis 0 heure, donc la valeur 36444,837 correspond à la date du 11/10/1999 et à l'heure 20h05. Le nombre de jours peut être négatif, mais les valeurs inférieures à -693594 (correspondant à la date 00.00.0000 de la Nativité du Christ) sont ignorées par les fonctions de conversion d'une date en type chaîne. Type de données ci-dessus TDateHeure les mêmes opérations sont définies que sur les nombres réels, et les expressions de ce type peuvent impliquer des constantes et des variables de types entiers et réels. Parce que le type TDateHeure compatible avec le format des nombres réels, vous pouvez facilement déterminer une date qui est en avance ou en arrière de plusieurs jours par rapport à une date donnée : pour ce faire, il suffit respectivement d'ajouter ou de soustraire l'entier souhaité à la date donnée. 1.2 Types structurés Tous les types structurés (et en Pascal Objet il y en a quatre : tableaux, enregistrements, ensembles et fichiers) se caractérisent par la multiplicité des éléments qui forment ce type. Chaque élément, à son tour, peut appartenir à un type structuré, ce qui permet de parler d'une éventuelle imbrication de types. Object Pascal autorise une profondeur arbitraire d'imbrication des types, mais la longueur totale de chacun d'entre eux dans la représentation interne ne doit pas dépasser 2 Go. Pour des raisons de compatibilité avec le Pascal standard, Object Pascal permet de placer un mot réservé avant une déclaration de type structuré emballé, demandant au compilateur de sauvegarder autant que possible la mémoire allouée aux objets de type structuré ; mais le compilateur ignore en fait cette instruction : le « packaging » des données dans Object Pascal se fait automatiquement dans la mesure du possible. 1.2.1 Tableaux Les tableaux dans Object Pascal sont similaires à bien des égards aux types de données similaires dans d’autres langages de programmation. Une particularité des tableaux est que tous leurs composants sont des données du même type (éventuellement structurées). Ces composants peuvent être facilement organisés et chacun d'entre eux est accessible simplement en spécifiant son numéro de série. La description du type de tableau est spécifiée comme suit : <имя типа>= tableau [<сп.инд.типов>] de<тип>; Ici<имя типа>- identifiant correct ; tableau de- mots réservés (tableau, from) ;<сп.инд.типов>- une liste d'un ou plusieurs types d'index, séparés par des virgules ; les crochets encadrant la liste sont une exigence de syntaxe ;<тип>- tout type de Pascal Objet. Tous les types ordinaux d'une capacité ne dépassant pas 2 Go peuvent être utilisés comme types d'index dans Object Pascal (c'est-à-dire, sauf Mot Long Et Int64) La profondeur d'imbrication des types structurés en général et, par conséquent, des tableaux est arbitraire, donc le nombre d'éléments dans la liste des types d'index (taille du tableau) n'est pas limité, cependant, la longueur totale de la représentation interne de tout la baie ne peut pas dépasser 2 Go. Dans la mémoire du PC, les éléments du tableau se succèdent de telle manière que lors du passage des adresses basses aux adresses élevées, l'index le plus à droite du tableau change le plus rapidement. En Pascal Objet, vous pouvez utiliser un seul opérateur d'affectation pour transférer tous les éléments d'un tableau vers un autre tableau du même type. 1.2.2 Dossiers Enregistrer
est une structure de données composée d'un nombre fixe de composants appelés champs d'un enregistrement. Contrairement à un tableau, les composants (champs) d’un enregistrement peuvent être de différents types. Pour permettre de faire référence à l'un ou l'autre composant d'un enregistrement, les champs sont nommés. La structure d'une déclaration de type de publication est : <имятипа>=enregistrer<сп.полей>fin; Ici<имя типа>- identifiant correct ; enregistrement/fin- mots réservés (enregistrement, fin) ;<сп.полей>- liste des champs ; est une séquence de sections d'un enregistrement séparées par un point-virgule. Chaque section d'un enregistrement se compose d'un ou plusieurs identifiants de champ, séparés par des virgules. Offre cas de, qui ouvre la partie variante, est superficiellement similaire à l'opérateur de sélection correspondant, mais ne joue en fait que le rôle d'une sorte de mot de service désignant le début de la partie variante. C'est pourquoi à la fin de la partie variante, vous ne devez pas mettre fin comme un couple pour cas de. (Comme la partie variante est toujours la dernière de l'enregistrement, elle est toujours suivie de la fin, mais uniquement par paire à enregistrer). Clé de sélection de phrase cas de est effectivement ignoré par le compilateur : la seule exigence en Pascal Objet est que la clé définisse un type ordinal standard ou prédéclaré. Les noms de champs doivent être uniques dans l'enregistrement dans lequel ils sont déclarés. Toutefois, si les enregistrements contiennent des champs d'enregistrement, c'est-à-dire s'ils sont imbriqués les uns dans les autres, les noms peuvent être répétés à différents niveaux d'imbrication.
1.2.3 Ensembles Ensembles
- ce sont des ensembles d'objets du même type logiquement liés les uns aux autres. La nature des relations entre les objets est uniquement implicite par le programmeur et n'est en aucun cas contrôlée par Object Pascal. Le nombre d'éléments inclus dans un ensemble peut varier de 0 à 256 (un ensemble qui ne contient pas d'éléments est dit vide). C'est l'inconstance du nombre de leurs éléments qui différencie les ensembles des tableaux et des enregistrements. Deux ensembles sont considérés comme équivalents si et seulement si tous leurs éléments sont identiques et que l'ordre des éléments dans l'ensemble est indifférent. Si tous les éléments d’un ensemble sont également inclus dans un autre, le premier ensemble est dit inclus dans le second. Un ensemble vide est inclus dans tout autre ensemble. La description du type d'ensemble est : <имя типа>= ensemble de<базовый тип>; Ici<имя типа>- identifiant correct ; ensemble de- mots réservés (ensemble, de) ;<базовый тип>- le type de base des éléments de l'ensemble, qui peut être n'importe quel type ordinal, sauf Mot, entier, entier long, Int64
. Pour définir un ensemble, on utilise ce qu'on appelle le constructeur d'ensemble : une liste de spécifications des éléments de l'ensemble, séparées par des virgules ; la liste est entourée de crochets. Les spécifications d’éléments peuvent être des constantes ou des expressions d’un type de base, ou un type de plage du même type de base. La structure interne de l'ensemble est telle que chacun de ses éléments se voit attribuer un chiffre binaire (un bit) ; si un élément est inclus dans un ensemble, le bit correspondant a la valeur 1, sinon - 0. Dans le même temps, l'unité minimale de mémoire est un octet contenant 8 bits, donc le compilateur a alloué un octet aux ensembles, et en conséquence, la puissance de chacun d’eux est devenue égale à 8 éléments. La capacité maximale de l'ensemble est de 256 éléments. Pour de tels ensembles, le compilateur alloue 16 octets adjacents. Et encore une expérience : changez la plage du type de base en 1..256. Bien que la capacité de ce type soit de 256 éléments, lors de la tentative de compilation d'un programme, le compilateur signalera l'erreur : Les ensembles peuvent avoir au plus 256 éléments car la numérotation des éléments de l'ensemble commence à zéro quelle que soit la limite inférieure déclarée dans le programme. Le compilateur permet l'utilisation comme type de base d'un type plage entière avec une limite minimale de 0 et un maximum de 255, ou de tout type énuméré ne comportant pas plus de 256 éléments (la cardinalité maximale d'un type énuméré est de 65 536 éléments). 1.3 Chaînes Les types suivants sont utilisés pour le traitement de texte dans Object Pascal : chaîne courte chaîne courte ou chaîne [n], où n<= 255; longue chaîne chaîne
; ligne large Chaîne large
; chaîne de terminal nul pchar
. Ce que ces types ont en commun, c'est que chaque chaîne est traitée comme un tableau unidimensionnel de caractères, dont le nombre de caractères peut changer dans un programme en cours d'exécution : pour la chaîne [n], la longueur de la chaîne passe de 0 à n, pour chaîne Et pchar- de 0 à 2 Go. Le Pascal standard utilise uniquement des chaînes courtes Chaîne [n]. En mémoire, une telle chaîne se voit attribuer n+i octets, le premier octet contient la longueur actuelle de la chaîne et les caractères eux-mêmes sont localisés à partir du 2ème octet. Étant donné que la longueur de la chaîne dans ce cas est d'un octet, la longueur maximale d'une chaîne courte ne peut pas dépasser 255 caractères. Le type standard est utilisé pour déclarer une chaîne courte de longueur maximale Chaîne courte(équivalent Chaîne). Windows utilise largement des chaînes à terminal nul, qui sont des chaînes de caractères délimitées par le caractère #o. La longueur maximale d'une telle chaîne n'est limitée que par la mémoire disponible et peut être très grande. Un nouveau type a été introduit dans les versions 32 bits de Delphi chaîne, combinant les commodités des deux types. Lorsque vous travaillez avec ce type, la mémoire est allouée selon les besoins (dynamiquement) et est limitée par la mémoire disponible pour le programme. 1.4 Pointeurs et mémoire dynamique 1.4.1 Mémoire dynamique Mémoire dynamique- il s'agit de la RAM PC fournie au programme lors de son fonctionnement. Le placement dynamique des données signifie l'utilisation de la mémoire dynamique directement pendant l'exécution du programme. En revanche, l'allocation statique est effectuée par le compilateur Object Pascal lors de la compilation du programme. Avec le placement dynamique, ni le type ni la quantité de données à placer ne sont connus à l'avance. 1.4.2 Panneaux indicateurs La RAM PC est un ensemble de cellules pour stocker des informations - des octets, chacun ayant son propre numéro. Ces numéros sont appelés adresses, ils permettent d'accéder à n'importe quel octet de mémoire. Object Pascal fournit au programmeur un moyen flexible de gérer la mémoire dynamique - ce qu'on appelle les pointeurs. Un pointeur est une variable qui contient l’adresse d’un octet de mémoire comme valeur. À l’aide de pointeurs, vous pouvez placer n’importe quel type de données connu en Pascal Objet dans la mémoire dynamique. Seulement certains d'entre eux ( Octet, Char, ShortInt, Booléen) occupent un octet dans la représentation interne, le reste - plusieurs octets adjacents. Par conséquent, le pointeur n’adresse en réalité que le premier octet de données. Généralement, un pointeur est associé à un type de données. Nous appellerons ces pointeurs typés. Pour déclarer un pointeur typé, utilisez l'icône ^, qui est placée devant le type correspondant. En Pascal Objet, vous pouvez déclarer un pointeur sans avoir à l'associer à un type de données spécifique. Cela se fait en utilisant le type standard aiguille, Par exemple: Les pointeurs de ce type seront appelés non typés. Étant donné que les pointeurs non typés ne sont pas associés à un type spécifique, ils peuvent être utilisés pour allouer dynamiquement des données dont la structure et le type changent au fur et à mesure de l'exécution du programme. Comme mentionné, les valeurs des pointeurs sont les adresses des variables en mémoire, on peut donc s'attendre à ce que la valeur d'un pointeur puisse être transmise à un autre. En fait, ce n'est pas vrai. En Pascal Objet, vous ne pouvez transmettre des valeurs qu'entre des pointeurs associés au même type de données. 1.4.3 Allocation et libération de mémoire dynamique Toute la mémoire dynamique dans Object Pascal est traitée comme un tableau continu d'octets, appelé tas. La mémoire pour toute variable allouée dynamiquement est allouée par la procédure New. Le paramètre pour appeler cette procédure est un pointeur typé. Suite à l'accès, le pointeur acquiert une valeur correspondant à l'adresse à partir de laquelle les données peuvent être placées. La valeur vers laquelle pointe le pointeur, c'est-à-dire les données réelles allouées au tas, est indiquée par le signe ^, placé immédiatement après le pointeur. S'il n'y a pas de signe ^ après le pointeur, cela signifie l'adresse où se trouvent les données. Il est logique de repenser à ce qui vient d'être dit : la valeur de tout pointeur est une adresse, et pour indiquer qu'on ne parle pas de l'adresse, mais des données qui se trouvent à cette adresse, un ^ est placé après le pointeur (parfois appelé pointeur de déréférencement). Les données allouées dynamiquement peuvent être utilisées n'importe où dans le programme où elles sont valides pour les constantes et les variables du type approprié. La mémoire dynamique peut non seulement être extraite du tas, mais également restituée. Pour ce faire, utilisez la procédure Dispose. Par exemple, les opérateurs Disposer(pJ); Disposer(pR); renverra au tas la mémoire qui était précédemment attribuée aux pointeurs pJ et pR (voir ci-dessus). Notez que la procédure Dispose (pPtr) ne modifie pas la valeur du pointeur pPtr, mais renvoie uniquement la mémoire précédemment associée à ce pointeur au tas. Cependant, réappliquer la procédure à un pointeur libre entraînera une erreur d’exécution. Le programmeur peut marquer le pointeur libéré avec le mot réservé nul. 1.5 Type d'alias Pour n'importe quel type, vous pouvez déclarer autant d'alias que vous le souhaitez. Par exemple: TMyInteger = Entier ; À l’avenir, l’alias pourra être utilisé de la même manière que le type de base : Mylnt : TMyInteger ; Mylnt := 2*Round(pi); Ces types d'alias sont généralement utilisés pour améliorer la visibilité du code du programme. Cependant, en Pascal Objet vous pouvez déclarer des alias fortement typés en ajoutant le mot réservé type avant le nom du type de base : TMyIntegerType = tapez Entier ; MylntVar : TMyIntegerType ; Du point de vue du compilateur, les alias typés sont compatibles avec le type de base dans différents types d'expressions, mais ils déclarent en réalité un nouveau type de données, ils ne peuvent donc pas être utilisés comme paramètres formels pour appeler des sous-programmes à la place du type de base. Si par exemple une procédure est déclarée function MylntFunc(APar : entier) : Entier ; alors un tel appel à elle MylntFunc(MylntVar) sera considéré comme erroné par le compilateur. Les alias fortement typés obligent le compilateur à générer des informations de type d'exécution (RTTI). Ces informations sont généralement utilisées par l'environnement Delphi pour prendre en charge le fonctionnement de différents types d'éditeurs. 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 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 : Opérations valides : 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. Ce serait une erreur d’écrire un nombre réel comme celui-ci : Un nombre réel sous forme à virgule flottante (forme scientifique) s'écrit sous forme de paire Opérations valides : 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 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) : Types de langage structuré Les types structurés incluent : un tableau, un enregistrement, un ensemble, un fichier, etc. Tous définissent le (ou les) type(s) 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 : 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 ; 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 : 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) Type de données d'intervalle
Nom
Longueur, octets
Plage de valeurs
Cardinal
4
0. .. 2 147 483 647
Octet
1
0...255
Raccourci
1
-128...+127
Petitint
2
-32 768...+32 767
Mot
2
0...65 535
Entier
4
Entier long
4
-2 147 483 648...+2 147 483 647
Int64
8
-9*1018...+9*1018
Mot Long
4
0. . .4 294 967 295
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 (w)
Octet
Renvoie l'arc le plus élevé de l'argument
Salut (je)
Même
Renvoie le troisième octet
Lo(je)
“
Renvoie l'octet de poids faible de l'argument
Faible)
“
Même
impair(l)
Booléen
Renvoie True 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-l)
carré(x)
X
Renvoie le carré de l'argument
échanger(i)
Entier
Échange des octets dans un mot
échanger(w)
Mot
Même
Code
Symbole
Code.
Symbole
Code.
Symbole
Code
Symbole
0
NUL
32
B.L.
64
@
96
"
1
ZON
33
!
65
UN
97
UN
2
STX
34
“
66
DANS
98
b
3
ETX
35
#
67
AVEC
99
Avec
4
EOT
36
$
68
D
100
d
5
ENQ
37
%
69
E
101
e
6
ACCK
38
&
70
F
102
F
7
BEL
39
"
71
g
103
d
8"
BS.
40
(
72
N
104
h
9
HT
41
)
73
je
105
je
10
LF
42
*
74
J.
106
j
11
Vermont
43
+
75
À
107
k
12
FR
44
F
76
L
108
1
13
CR
45
-
77
M
109
m
14
DONC
46
78
N
110
n
15
SI.
47
/
79
0
111
Ô
16
DEL
48
0
80
R.
112
P.
17
DC1
49
1
81
Q
113
q
18
DC2
50
2
82
R.
114
r
19
DC3
51
3
83
S
115
s
20
DD 4
52
4
84
T
116
t
21
N.A.K.
53
5
85
U
117
toi
22
SYN
54
6
86
V
118
v
23
ETB
55
7
87
W
119
W
24
PEUT
56
8
88
X
120
X
25
E.M.
57
9
89
Oui
121
U
26
SOUS
58
:
90
Z
.122
z
27
ÉCHAP
59
;
91
t
123
{
28
FS
60
<
92
\
124
1
29
G.S.
61
=
93
]
125
}
30
R.S.
62
>
94
L
126
~
31
NOUS
63
F
95
127
r
Les types simples incluent les types ordinal, réel, chaîne et adresse (pointeur). Ils définissent tous le type d’une seule valeur.
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.
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 :
Type de caractère (Caractère) est un type de données composé d'un 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 :
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 :
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.
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
0,5 (correct 0,5)
12. (correctement 12,0 ou 12)
<мантисса>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
- affectation;
- tout arithmétique : +, - ,*, /;
- comparaison:<, >, >=, <=, <>, =.
TAPER
Siècle = 1..21 ; (sous-plage de type entier)
Lettres Majuscules = "A". "Z"; (sous-plage de type Char)
Tableau [plage] de ElementType ;
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.
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.
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.
