Description et utilisation
Un type énuméré est défini comme un ensemble d'identificateurs qui, en termes de langage, jouent le même rôle que les constantes nommées ordinaires, mais associés à ce type. La description classique d'un type d'énumération en Pascal est la suivante:
Type Cardigan \u003d (clubs, diamants, coeurs, piques);
Voici la déclaration du type de données Cardsuit (card suit), dont les valeurs peuvent être l'une des quatre constantes listées. Une variable de type Cardsuit peut prendre l'une des valeurs clubs, losanges, coeurs, piques, elle est autorisée à comparer les valeurs du type d'énumération pour l'égalité ou l'inégalité, et également les utiliser dans les instructions de sélection (dans le cas Pascal) comme valeurs identifiant des options.
L'utilisation d'énumérations vous permet de faire codes source les programmes sont plus lisibles, car ils vous permettent de remplacer des «nombres magiques» encodant certaines valeurs par des noms lisibles.
Sur la base d'énumérations dans certaines langues, des types d'ensemble peuvent être créés. Dans de tels cas, l'ensemble est compris (et décrit) comme un ensemble non ordonné valeurs uniques type d'énumération.
Un type énuméré peut être utilisé dans les déclarations de variables et les paramètres formels de fonctions (procédures, méthodes). Les valeurs énumérées peuvent être affectées aux variables correspondantes et passées par des paramètres des types correspondants dans la fonction. De plus, les comparaisons d'égalité et d'inégalité des valeurs énumérées sont toujours prises en charge. Certaines langues prennent également en charge d'autres opérations de comparaison pour les valeurs énumérées. Le résultat de la comparaison de deux valeurs énumérées dans de tels cas est déterminé, en règle générale, par l'ordre dans lequel ces valeurs apparaissent dans la déclaration de type - la valeur qui apparaît plus tôt dans la déclaration de type est considérée comme "inférieure" à la valeur qui apparaît plus tard. Parfois, un type énuméré ou une plage de valeurs d'un type énuméré peut également être utilisé comme type d'index pour un tableau. Dans ce cas, il y a un élément dans le tableau pour chaque valeur de la plage sélectionnée, et l'ordre réel des éléments correspond à l'ordre des valeurs dans la déclaration de type.
la mise en oeuvre
En règle générale, lors de la compilation, les valeurs d'énumération sont représentées à l'aide d'entiers. Selon le langage de programmation spécifique, une telle représentation peut être soit complètement cachée au programmeur, soit accessible à lui en utilisant l'une ou l'autre "solution de contournement" (par exemple, conversion forcée d'une valeur d'énumération en une valeur entière), ou même contrôlée par le programmeur ( dans de tels cas, le programmeur a la capacité de spécifier explicitement quels nombres encoderont tout ou partie des valeurs du type d'énumération). Toutes les options ont leurs côtés positifs et négatifs. D'une part, la possibilité d'utiliser les valeurs numériques des constantes qui composent un type d'énumération, surtout s'il est abusé, rend inutile l'utilisation de ces types et crée un risque d'erreurs (lors de l'utilisation de valeurs numériques pour lesquelles il n'y a pas de constantes correspondantes dans le type). D'autre part, la gestion de la valeur explicite donne caractéristiques supplémentaires... Par exemple, il permet l'utilisation de types d'énumération lors de l'organisation d'une interface avec des modules écrits dans d'autres langages, s'ils utilisent ou retournent des valeurs codées en entier à partir d'un ensemble prédéfini.
Une autre opportunité offerte par les types énumérés au niveau de l'implémentation du langage est l'économie de mémoire. Avec une petite taille d'un type d'énumération, quelques bits suffisent pour stocker une valeur de ce type (le type Cardsuit ci-dessus ne nécessite que deux bits par valeur, alors qu'un entier standard sur la plupart des architectures utilisées prend 32 bits - 16 fois plus), et le compilateur peut utiliser ce fait pour compacter le stockage des données en mémoire. Cela peut être particulièrement important si plusieurs valeurs de types d'énumération sont stockées dans un enregistrement - le compactage des enregistrements lors du traitement d'un grand nombre d'entre eux peut libérer beaucoup de mémoire. Cependant, il convient de noter que les compilateurs n'implémentent généralement pas cette fonctionnalité, du moins pas récemment, lorsque mémoire d'ordinateur a chuté de manière significative.
Critique
Le type d'énumération est traditionnel pour les langages de programmation avancés, est largement utilisé et est souvent pris pour acquis. Cependant, ce type n'est pas non plus sans critiques de la part des théoriciens et des praticiens de la programmation. Ainsi, lors du développement du langage de programmation Oberon, les types énumérés ont été inclus dans la liste des fonctionnalités qui ont été supprimées du langage. Niklaus Wirth, le développeur du langage, a donné les raisons suivantes:
D'un autre côté, par exemple, en Java, qui à l'origine ne contenait pas de type énuméré, ce type a ensuite été introduit pour des raisons non seulement de commodité, mais aussi de fiabilité: le problème de l'utilisation de groupes de constantes nommées au lieu d'énumérations est qu'il n'y a pas de contrôle du compilateur sur l'unicité des valeurs constantes et pour la possibilité d'assignation aléatoire valeurs variablesqui ne correspondent à aucune de ces constantes.
Description des énumérations dans différentes langues
Ada
Combinaison de cartes Enum (CLUBS, DIAMANTS, COEURS, SPADES);
Les langages dynamiques faiblement typés avec une syntaxe de type C (par exemple perl ou JavaScript) n'ont généralement pas d'énumérations.
C ++
C #
Enum Cardsuit (Clubs, Diamants, Spades, Hearts);
Java
Enum Cardsuit (Clubs, Diamonds, Spades, Hearts)
Haskell
Dans certains langages de programmation (par exemple, dans le langage Haskell) utilisant des types algébriques, il est possible d'émuler des énumérations. Par exemple, voici comment un type booléen est codé qui contient deux identificateurs pour représenter les valeurs de vérité:
Data Bool \u003d False | Vrai
Remarques
Fondation Wikimedia. 2010.
Wikipédia
Pour des raisons techniques, Bool est redirigé ici. Vous pouvez en savoir plus sur Bool ici: stdbool.h. Type de données logique, booléen (type de données booléen anglais ou logique) type primitif données en informatique qui peuvent prendre deux possibles ... Wikipedia
En théorie de la programmation, tout type dont les valeurs sont des valeurs de certains autres types, «enveloppées» par des constructeurs de type algébrique. En d'autres termes, un type de données algébrique a un ensemble de constructeurs de type, chacun desquels ... ... Wikipedia
Entier, type entier data (eng. Integer), en informatique, l'un des types de données les plus simples et les plus courants dans les langages de programmation. Sert à représenter des nombres entiers. Beaucoup de nombres de ce type représentent ... ... Wikipedia
Un type primitif (intégré, de base) est un type de données fourni par un langage de programmation comme unité intégrée de base du langage. Selon la langue et sa mise en œuvre, l'ensemble de ces types peut varier considérablement. Il est déterminé par ... ... Wikipedia
Ce terme a d'autres significations, voir ensemble (significations). Un ensemble, un type et une structure de données en informatique, est une implémentation d'un ensemble d'objets mathématiques. L'ensemble de types de données vous permet de stocker un nombre limité de valeurs ... ... Wikipedia
Certains langages de programmation fournissent un type de données spécial pour les nombres complexes. Le fait d'avoir un type intégré facilite le stockage et le calcul de valeurs complexes. Sommaire 1 Arithmétique sur complexe 2 Prise en charge des langues ... Wikipedia
Pour améliorer cet article en informatique Souhaitable?: Trouvez et placez sous forme de notes de bas de page des liens vers des sources faisant autorité confirmant ce qui a été écrit. Mettre des notes de bas de page, rendre plus précis ... Wikipedia
Variablessont les grandeurs dont les valeurs peut changerpendant l'exécution du programme. Chaque variable a son propre nom unique, construit selon les règles indiquées au début du chapitre. La longueur maximale possible d'un nom dépend de l'implémentation Pascal; théoriquement, vous pouvez donner des noms de variables jusqu'à 63 caractères, ce qui n'est guère pertinent - généralement les noms ne dépassent pas 5-10 caractères.
Étant donné que toutes les données de la mémoire de l'ordinateur sont stockées sous forme numérique et dans le système de nombres binaires, en plus du nom, la variable doit être affectée et un typedéfinir plage de valeursaccepté par la variable, et manière de le traitermachine. Expliquons cela avec un exemple. Comme vous pouvez le voir dans l'annexe 1, la lettre majuscule latine «A» a le code décimal 65 ou 01000001 en binaire. Aucune autre information sur typedonnées stockées dans une cellule de mémoire, il serait impossible pour l'ordinateur de décider ce que sont exactement ces données - le nombre 65, le code de caractère «A» ou autre chose. Dans tout langage de programmation, y compris Pascal, il existe un ensemble standard de types auxquels tel ou tel ensemble de cellules de mémoire peut être attribué. Il est pratique de tabuler des informations sur les types de données de Pascal. Les lignes de ce tableau seront triées par ancienneté des types, du plus bas, qui nécessite le plus petit nombre d'octets à représenter, et représente donc la plus petite plage de valeurs possibles, au plus élevé, qui représente la plus grande plage de valeurs. Le tableau ne montre pas tout le possible, mais seulement les types de données de base de Pascal.
|
Mot-clé de Pascal |
Tapez le nom et la description |
Taille de la mémoire, octets |
Plage de valeurs possibles |
|
Boolean: stocke une variable booléenne | |||
|
Symbolique: stocke le code d'un caractère à partir d'un ensemble de codes ASCII |
de 0 à 255 inclus (2 8 \u003d 256) |
||
|
Entier | |||
|
Entier non signé |
± 2 16 - la plage est deux fois plus grande, car le 16e bit n'est pas occupé sous le signe du nombre |
||
|
Entier long: pour représenter de grandes valeurs entières | |||
|
Un nombre réel avec une précision de représentation jusqu'à 11-12 chiffres dans la partie fractionnaire |
~ 2.9*10 -39 - 1.7*10 38 |
||
|
Un nombre réel avec une précision de 15 à 16 chiffres dans la partie fractionnaire |
~ 5*10 -324 – 1.7*10 308 |
||
|
Une séquence de caractères de type Char, d'une longueur de 1 à 255 |
2-256 (chaîne de données + 1 octet pour stocker sa longueur) |
Toutes les lignes de texte composées de caractères imprimables |
Théoriquement, 1 bit suffirait pour écrire une variable booléenne, mais l'unité de mémoire adressable minimum est de 1 octet (voir Annexe 1). Dans la même annexe, clarifiez exactement comment la quantité de mémoire en octets allouée à une variable affecte la plage de valeurs qu'elle représente.
Les types entiers et caractères sont appelés génériquement ordinal, soulignant ainsi que ces types ont un ensemble fini de valeurs qui peuvent être ordonnées ou énumérées. Rappelez-vous que les valeurs réelles sont stockées dans la mémoire de l'ordinateur différemment des entiers - à savoir, comme un ensemble de mantisses et d'ordre.
Bien entendu, la tâche de choisir les bons types de données incombe entièrement au programmeur. Par exemple, si un compteur de votre programme peut prendre des valeurs entières de 1 à 100000, il serait erroné de le décrire comme une variable de type Integer - après tout, 2 15 \u003d 32768 et lorsque le compteur atteint cette valeur, déchargesa valeur, qui devient -32768. Dans ce cas, il serait raisonnable de décrire le compteur comme une variable de type Longint.
Les variables sont décrites dans le programme par un opérateur de la forme suivante:
var List1: Type1;
Liste 2: Type2;
ListN: TypeN;
Ici liste- un ensemble de noms de variables séparés par des virgules (ou une variable), et un type- l'un des types de données mentionnés ci-dessus. Par exemple, la construction
décrit 2 variables réelles nommées t et r, ainsi qu'une variable entière nommée i. Mot-clévar peut être dupliqué, mais généralement pas nécessaire. L'abréviation var est dérivée du mot anglais "Variable".
La leçon expliquera l'algorithme de création de types de données utilisateur en Pascal (Type). Les exemples seront triés.
Les types de données en Pascal sont divisés en simples et complexes.
Les types simples incluent standard, énumérable et limité.
Aux types complexes - tableaux, ensembles, enregistrements, fichiers. Les éléments de types complexes peuvent être des types simples et complexes. Nous apprendrons à connaître les types de données complexes plus tard.
L'un des types les plus courants est le type standard ordinal.
Type standard ordinaire désigne un ensemble linéaire fini de valeurs. Il comprend généralement types entiers, octets, caractères et booléens.
Nouveaux types de données (personnalisés) sont nécessaires principalement pour plus de clarté et de commodité:
Exemple: Une matrice 10 x 50 est spécifiée. Décrivez la matrice à l'aide d'un type de données personnalisé
procédure p (a: tableau d'entiers);
Mais devrait créer un type de données et écrivez-le comme ceci:
| 1 2 | type vecteur \u003d tableau [1 .. 10] d'entier; procédure var p (a: vecteur); |
type vector \u003d tableau d'entiers; procédure var p (a: vecteur);
Exemples de description de tableaux à l'aide de nouveaux types
type vector \u003d tableau d'entiers; matritsa \u003d tableau de vecteurs;
| 1 | type matritsa \u003d tableau [1 .. 8] du tableau [1 .. 10] d'entier; |
type matritsa \u003d tableau de tableau d'entiers;
| 1 | type matritsa \u003d tableau [1 .. 8, 1 .. 10] d'entier; |
type matritsa \u003d tableau d'entiers;
Dans l'exemple suivant, les variables c et ré sont décrits de la même manière:
| 1 2 3 4 5 6 | type vecteur \u003d tableau [1 .. 10] d'entier; matritsa \u003d tableau [1 .. 8] de vecteur; var a, b: vecteur; c: matritsa; d: tableau [1 .. 8] de vecteur; |
type vector \u003d tableau d'entiers; matritsa \u003d tableau de vecteur; var a, b: vecteur; c: matritsa; d: tableau de vecteur;
Type 1: Les tableaux a, b et c sont donnés. Trouvez la moyenne arithmétique des éléments minimaux d'un tableau (utilisez la mise en forme de tableau et).
Lors de la description des procédures, utilisez types personnalisés Les données
Type énuméré et type d'intervalle en Pascal
Type énuméré
Le programme peut utiliser des variables d'un type qui ne correspond à aucun des types standard.
Par exemple, un type peut être spécifié en énumérant des valeurs lorsqu'il est déclaré; variable de ce type peut prendre n'importe laquelle de ces valeurs.
Ces valeurs ne peuvent pas être des chaînes, elles ne peuvent pas être imprimées et ne peuvent pas être entrées dans un ordinateur en utilisant les instructions Read et Write.
Prenons un exemple de création d'un type énuméré en Pascal:
| type pt \u003d (mot1, mot2, ... motN); var w: pt; |
type pt \u003d (mot1, mot2, ... motN); var w: pt;
Type d'intervalle
Type d'intervalle définit un sous-ensemble spécifique de valeurs qu'une variable donnée peut prendre. Créé en spécifiant la valeur la plus basse et la plus élevée type ordinal ... En tant que constantes (valeurs minimales et maximales), les valeurs de types simples sauf pour les vrais types.
Prenons un exemple de déclaration de type intervalle:
| a: min .. max; |
Utilisation conjointe des types énumérés et intervalle
Une variable de type intervalle peut être définie avec une racine du type énuméré sous-jacent... Prenons un exemple:
Exemple: Si la variable b peut prendre l'une des valeurs rouge, jaune, vert, alors cette variable peut être décrite comme suit: b: rouge.. vert; type de base pour b est le type couleur:
| type couleur \u003d (rouge, jaune, vert, bleu); var b: rouge .. vert; commencer b: \u003d rouge; writeln (b); b: \u003d jaune; writeln (b); b: \u003d vert; writeln (b); readln end. |
type couleur \u003d (rouge, jaune, vert, bleu); var b: rouge.. vert; commencer b: \u003d rouge; writeln (b); b: \u003d jaune; writeln (b); b: \u003d vert; writeln (b); readln end.
DANS cet exemple le type de couleur est basique. La variable b d'un type d'intervalle est définie à l'aide d'un type d'énumération de base.
Exemple: On sait combien de jours il y a dans chaque mois de l'année. Combien de jours en été?
31,28,31,30,31,30,31,31,30,31,30,31
L'une des options pour résoudre ce problème ressemble à ceci:
Afficher la solution:
| 1 2 3 4 5 6 7 8 | const dni: tableau [1 .. 12] d'octet \u003d (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31); var s, i: entier; commencer s: \u003d 0; pour i: \u003d 6 à 8 faire s: \u003d s + dni [i]; (mois d'été - 6, 7, 8) writeln (s) fin. |
const dni: tableau d'octets \u003d (31,28,31,30,31,30,31,31,30,31,30,31); var s, i: entier; commencer s: \u003d 0; pour i: \u003d 6 à 8 faire s: \u003d s + dni [i]; (mois d'été - 6, 7, 8) fin d'écriture (s).
Code cette décision n'a pas la meilleure clarté, de plus, vous devez calculer vous-même les nombres des mois de début et de fin d'été (6 et 8).
La commodité et la visibilité de ces programmes peuvent être améliorées comme suit:
Afficher la solution:
| 1 2 3 4 5 6 7 8 9 | TYPE mes \u003d (janvier, février, mars, avril, mai, juin, juillet, août, septembre, octobre, novembre, décembre); CONST dni: tableau [janvier .. décembre] de Byte \u003d (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31); VAR s: entier; i: mes; (la variable de compteur de boucle i est de type mes, pas Integer) COMMENCER s: \u003d 0; pour i: \u003d juin à août do s: \u003d s + dni [i]; WriteLn (s) END. |
TYPE mes \u003d (janvier, février, mars, avril, mai, juin, juillet, août, septembre, octobre, novembre, décembre); CONST dni: tableau d'octets \u003d (31,28,31,30,31,30,31,31,30,31,30,31); VAR s: entier; i: mes; (la variable de compteur de boucle i est de type mes, pas Integer) BEGIN s: \u003d 0; pour i: \u003d juin à août do s: \u003d s + dni [i]; WriteLn (s) END.
Type 2: Déterminez s'il s'agit d'un week-end ou d'un jour ouvrable par le nom du jour de la semaine.
Type 3: Selon le mois de l'année, émettez un message "du froid" - si le mois d'hiver, et "chaleureusement" - si l'été.
Writeln (pribitie) fin.
var otpravlenie, pribitie: octet; commencer otpravlenie: \u003d 22; pribitie: \u003d otpravlenie + 10; writeln (pribitie) fin.
le programme au lieu de la réponse «8» affichera la réponse «32».
L'introduction d'un type de plage restreint évitera le mauvais résultat, mais le compilateur lèvera toujours une erreur:
| 1 2 3 4 5 6 | var otpravlenie, pribitie: 0 .. 24; commencer otpravlenie: \u003d 22; pribitie: \u003d otpravlenie + 10; writeln (pribitiedeva); var a: znak; commencer a: \u003d lev; si un<= strelets then writeln ("огонь" ) ; if (a>\u003d vesi) et (a<= bliznetsi) then writeln ("воздух" ) ; if (a>\u003d rak) et (a<= ribi) then writeln ("вода" ) ; if (a>\u003d kozerog) et (a<= deva) then writeln ("земля" ) ; end . |
type znak \u003d (four, lev, strelets, vesi, vodoley, bliznetsi, rak, skorpion, ribi, kozerog, telets, deva); var a: znak; commencer a: \u003d lev; si un<=strelets then writeln("огонь"); if (a>\u003d vesi) et (a<=bliznetsi) then writeln ("воздух"); if (a>\u003d rak) et (a<=ribi) then writeln ("вода"); if (a>\u003d kozerog) et (a<=deva) then writeln ("земля"); end.
Type 5: En fonction du nom de la fleur, indiquez-lui à quelle saison de l'année elle appartient:
Lors de la description d'une variable, vous devez spécifier son type. Le type d'une variable décrit l'ensemble de valeurs qu'elle peut prendre et les actions qui peuvent y être effectuées. La description de type définit un identifiant qui désigne le type.
Les types simples sont divisés en types standard (ordinaux) et énumérés (restreints).
Types standard
Turbo Pascal a quatre types standard intégrés: entier, réel, booléen et char.
Type entier
Turbo Pascal a cinq types d'entiers intégrés: shortint, integer, longint, byte (longueur d'octet) et word (longueur de mot). Chaque type désigne un sous-ensemble spécifique d'entiers, comme indiqué dans le tableau suivant.
Types d'entiers intégrés.
|
Intervalle |
Format |
|
|
8 bits signés |
||
|
16 bits signés |
||
|
2147483648 +2147483647 |
Signé 32 bits |
|
|
8 bits non signés |
||
|
16 bits non signés |
Les opérations arithmétiques sur les opérandes de type entier sont effectuées conformément aux règles suivantes:
- Un type de constante entier est le type entier intégré avec la plus petite plage qui inclut la valeur de cette constante entière.
- Dans le cas d'une opération binaire (une opération utilisant deux opérandes), les deux opérandes sont convertis dans leur type commun avant d'agir. Le type commun est le type entier intégré avec la plus petite plage qui inclut toutes les valeurs possibles des deux types. Par exemple, le type commun pour un entier et un entier de longueur d'octet est entier, et le type commun pour un entier de longueur de mot et un entier est un entier long. L'action est effectuée selon la précision du type générique et le type du résultat est le type générique.
- L'expression de droite dans l'instruction d'affectation est évaluée quelle que soit la taille de la variable de gauche.
Opérations effectuées sur des entiers:
«+» - ajout
"-" - soustraction
«*» - multiplication
SQR - mise au carré
DIV - après la division, rejette la partie fractionnaire
MOD - obtenir tout le reste après la division
ABS - module numérique
RANDOM (X) - obtenir un nombre aléatoire de 0 à X
A: \u003d 100; b: \u003d 60; un résultat DIV b - 1 un résultat MOD b - 40
Les variables de type entier sont décrites comme suit:
var liste de variables: type;
Par exemple: var a, p, n: integer;
Type réel (réel)
Un type réel est un sous-ensemble de nombres réels qui peuvent être représentés au format à virgule flottante avec un nombre fixe de chiffres. L'écriture d'une valeur à virgule flottante comprend généralement trois valeurs - m, b et e - telles que m * b e, où b est toujours 10 et m et e sont des entiers dans la plage réelle. Ces valeurs m et e définissent en outre la plage et la précision du type réel.
Il existe cinq types de types réels: réel, simple, double, exnende, comp. Les types réels diffèrent dans la plage et la précision de leurs valeurs associées
Plage et chiffres décimaux pour les types réels
|
Intervalle |
Nombres |
|
|
2,9x10E-39 à 1,7x10E 38 1,5x10E-45 jusqu'à 3,4x10E 38 5,0x10E-324 à 1,7x10E 308 3,4x10E-493 à 1,1x10E 403 2E 63 à 2E 63 |
Opérations effectuées sur des nombres réels:
- Toutes les opérations sont valides pour les entiers.
- SQRT (x) est la racine carrée du nombre x.
- SIN (X), COS (X), ARCTAN (X).
- LN (X) - logarithme naturel.
- EXP (X) -exposant X (ex x).
- EXP (X * LN (A)) - exponentiation (A x).
- Fonctions de conversion de type:
- TRUNC (X) - rejette la partie fractionnaire;
- ROUND (X) - arrondi.
- Quelques règles d'opérations arithmétiques:
- Si des nombres de type réel et entier sont rencontrés en opération arithmétique, le résultat sera de type réel.
- Toutes les parties constituantes de l'expression sont écrites sur une seule ligne.
- Seules les parenthèses sont utilisées.
- Vous ne pouvez pas mettre deux signes arithmétiques à la suite.
Les variables de type réel sont décrites comme suit:
var liste de variables: type;Par exemple:
var d, g, k: réel;Type de caractère (char)
Tout caractère entouré d'apostrophes est de type char. Pour représenter une apostrophe sous forme de variable symbolique, vous devez la placer dans une apostrophe: '' '' '.
Chaque symbole a son propre code et numéro. Les nombres séquentiels de chiffres 0,1..9 sont classés par ordre croissant. Les numéros de série des lettres sont également par ordre croissant, mais ne se succèdent pas nécessairement.
Les caractères de comparaison sont applicables aux données de caractères:
> , < , >=, <=, <> .
Par exemple: 'A'< ‘W’
Fonctions qui s'appliquent aux variables symboliques:
- ORD (X) - définit le nombre ordinal du caractère X. Ord («a») \u003d 97;
- CHR (X) - définit un caractère par un nombre. chr (97) \u003d 'a';
- PRED (X) - renvoie le caractère précédant le caractère X. Pred (‘B’) \u003d ’A’;
- SUCC (X) - renvoie le caractère suivant le caractère X. succ ("A") \u003d "B";
Type énuméré
Le type de données énuméré est ainsi nommé car il est spécifié comme une énumération de constantes dans un ordre strictement défini et dans une quantité strictement définie. Un type énuméré consiste en une liste de constantes. Les variables de ce type peuvent prendre la valeur de n'importe laquelle de ces constantes. La description du type énuméré est:
Type<имя типа>\u003d (liste des constantes); Var<имя переменной>:<имя типа>;où<список констант> est un type spécial de constantes séparées par des virgules qui ont leur propre nombre ordinal, à partir de 0.
Par exemple:
type direction \u003d (nord, sud, ouest, est); mois \u003d (juin, juillet, août, janvier); capacité \u003d (seau, baril, bidon, réservoir); virage var: direction; départ: mois; volume: capacité; virage var: (nord, sud, ouest, est); départ: (juin, juillet, août, janvier); volume: (seau, baril, bidon, réservoir);Vous pouvez exécuter les opérateurs d'affectation suivants:
Tournez: \u003d sud; départ: \u003d août; volume: \u003d réservoir;
mais vous ne pouvez pas faire de tâches mixtes:
Départ: \u003d sud; volume: \u003d août;
Les fonctions suivantes s'appliquent aux variables énumérées:
1. ORD - numéro de série
2. PRED est l'élément précédent
3. SUCC est l'élément suivant.
PRED (baril) \u003d seau; SUCC (sud) \u003d ouest; ORD (juillet) \u003d 1;Les variables d'un type énuméré peuvent être comparées car elles sont ordonnées et numérotées. Donc expressions: nord< юг, июнь < январь имеют значения TRUE, а юг>ouest et buck<бочка значение FАLSE.
Type limité
Si une variable n'accepte pas toutes les valeurs de son type, mais seulement dans une certaine plage, alors elle peut être considérée comme une variable d'un type limité. Chaque type restreint est spécifié en appliquant une contrainte sur les types de base.
Il est décrit comme ceci:
TYPE<имя типа>\u003d constante1 .. constante2Dans ce cas, les règles suivantes doivent être respectées:
- Les deux constantes contraintes doivent être du même type.
- Tout type simple peut être utilisé comme type de base, sauf real (real).
- La valeur initiale lors de la définition du type borné ne doit pas être supérieure à la valeur finale.
Vous pouvez le décrire directement dans la section description des variables:
var a, g: 0,63; char1, char2: 'a' .. 'z'.Dont l'ensemble de valeurs est une liste limitée d'identifiants.
YouTube encyclopédique
-
1 / 5
Un type énuméré est défini comme un ensemble d'identificateurs qui, en termes de langage, jouent le même rôle que les constantes nommées ordinaires, mais associés à ce type. La description classique d'un type d'énumération en Pascal est la suivante:
type Cardsuit \u003d (clubs, diamants, coeurs, piques);
Voici la déclaration du type de données Cardsuit (card suit), dont les valeurs peuvent être l'une des quatre constantes listées. Une variable de type Cardsuit peut prendre l'une des valeurs clubs, losanges, coeurs, piques, elle est autorisée à comparer les valeurs du type d'énumération pour l'égalité ou l'inégalité, et également les utiliser dans les instructions de sélection (dans le cas Pascal) comme valeurs identifiant des options.
L'utilisation d'énumérations vous permet de rendre les codes sources des programmes plus lisibles, puisqu'ils vous permettent de remplacer les "nombres magiques" encodant certaines valeurs par des noms lisibles.
Sur la base d'énumérations dans certaines langues, des types d'ensemble peuvent être créés. Dans de tels cas, un ensemble est compris (et décrit) comme une collection non ordonnée de valeurs uniques d'un type d'énumération.
Un type énuméré peut être utilisé dans les déclarations de variables et les paramètres formels de fonctions (procédures, méthodes). Les valeurs énumérées peuvent être affectées aux variables correspondantes et passées par des paramètres des types correspondants dans la fonction. De plus, les comparaisons d'égalité et d'inégalité des valeurs énumérées sont toujours prises en charge. Certaines langues prennent également en charge d'autres opérations de comparaison pour les valeurs énumérées. Le résultat de la comparaison de deux valeurs énumérées dans de tels cas est déterminé, en règle générale, par l'ordre dans lequel ces valeurs apparaissent dans la déclaration de type - la valeur qui apparaît plus tôt dans la déclaration de type est considérée comme "inférieure" à la valeur qui apparaît plus tard. Parfois, un type énuméré ou une plage de valeurs d'un type énuméré peut également être utilisé comme type d'index pour un tableau. Dans ce cas, il y a un élément dans le tableau pour chaque valeur de la plage sélectionnée, et l'ordre réel des éléments correspond à l'ordre des valeurs dans la déclaration de type.
la mise en oeuvre
En règle générale, lors de la compilation, les valeurs d'énumération sont représentées à l'aide d'entiers. Selon le langage de programmation spécifique, une telle représentation peut être soit complètement cachée du programmeur, soit disponible pour lui en utilisant une "solution de contournement" (par exemple, la conversion forcée d'une valeur d'énumération en une valeur entière), ou même contrôlée par le programmeur ( dans de tels cas, le programmeur a la capacité de spécifier explicitement quels nombres encoderont tout ou partie des valeurs du type d'énumération). Toutes les options ont leurs côtés positifs et négatifs. D'une part, la possibilité d'utiliser les valeurs numériques des constantes qui composent le type d'énumération, surtout en cas d'abus, rend l'utilisation de ces types dénuée de sens et crée un risque d'erreurs (lors de l'utilisation de valeurs numériques pour lesquelles il n'y a pas de constantes correspondantes dans le type). D'autre part, la gestion de la valeur explicite vous offre des options supplémentaires. Par exemple, il permet l'utilisation de types d'énumération lors de l'organisation d'une interface avec des modules écrits dans d'autres langages, s'ils utilisent ou retournent des valeurs codées en entier à partir d'un ensemble prédéfini.
Une autre opportunité offerte par les types énumérés au niveau de l'implémentation du langage est l'économie de mémoire. Avec une petite taille d'un type d'énumération, quelques bits suffisent pour stocker une valeur de ce type (le type Cardsuit ci-dessus ne nécessite que deux bits par valeur, alors qu'un entier standard sur la plupart des architectures utilisées prend 32 bits - 16 fois plus), et le compilateur peut utiliser ce fait pour compacter le stockage des données en mémoire. Cela peut être particulièrement important si plusieurs valeurs de types d'énumération sont stockées dans un enregistrement - le compactage des enregistrements lors du traitement d'un grand nombre d'entre eux peut libérer beaucoup de mémoire. Cependant, il convient de noter que les compilateurs n'implémentent généralement pas cette fonctionnalité, du moins récemment, lorsque la mémoire de l'ordinateur est devenue beaucoup moins chère.
Critique
Le type d'énumération est traditionnel pour les langages de programmation avancés, est largement utilisé et est souvent pris pour acquis. Cependant, ce type n'est pas non plus sans critiques de la part des théoriciens et des praticiens de la programmation. Ainsi, lors du développement du langage de programmation Oberon, les types énumérés ont été inclus dans la liste des fonctionnalités qui ont été supprimées du langage. Niklaus Wirth, le développeur du langage, a donné les raisons suivantes:
D'un autre côté, par exemple, en Java, qui à l'origine ne contenait pas de type énuméré, ce type a ensuite été introduit pour des raisons non seulement de commodité, mais aussi de fiabilité: le problème de l'utilisation de groupes de constantes nommées au lieu d'énumérations est qu'il n'y a pas de contrôle du compilateur sur l'unicité des valeurs constantes, et la possibilité d'attribution aléatoire de valeurs à des variables qui ne correspondent à aucune de ces constantes.
Description des énumérations dans différentes langues
Combinaison de cartes Enum (CLUBS, DIAMANTS, COEURS, SPADES);
Les langages dynamiques faiblement typés avec une syntaxe de type C (comme perl ou JavaScript) n'ont généralement pas d'énumérations.
