Концепция данных в языке Pascal. Реализация Delphi

 

МИНИСТЕРСТВО ОБРАЗОВАНИЯ РЕСПУБЛИКИ БЕЛАРУСЬ

УЧРЕЖДЕНИЕ ОБРАЗОВАНИЯ

МОГИЛЕВСКИЙ ГОСУДАРСТВЕНЫЙ УНИВЕРСТИТЕТ

ИМ. А. А. КУЛЕШОВА

Курсовая работа

Концепция данных в языке Pascal.

Реализация Delphi

Куспиц Лилии Александровны

студентки физико – математического

факультета

4-го курса группы  «Е»

Руководитель:

Каменская Наталья Евгеньевна

старший преподаватель кафедры математического анализа и дифференциальных уравнений

 

РЕФЕРАТ

Объем работы: страниц 69. Курсовая работа состоит из реферата, введения, восьми глав, заключения, списка использованной литературы (всего 8 источников), 15 приложений.

Ключевые слова: концепция данных в PASCAL, типы данных в PASCAL.

Таблицы: количество таблиц 5.

Рисунки: количество рисунков 2.

Приложение: количество приложений 15.

Предмет исследования: переменные, константы, концепция данных в языке программирования PASCAL.

Объект исследования: реализация концепции данных в PASCAL на практике.

Цель исследования: детальное рассмотрение теоретических аспектов концепции данных в PASCAL и реализация в DELPHI.

Методы исследования: сравнение, анализ, синтез, обобщение.

Результаты  исследования: структурирование полученных знаний, применение их на практике.

Сфера применения результатов: преподавание программирования.

 

СОДЕРЖАНИЕ

 

ВВЕДЕНИЕ

Delphi — результат развития  языка Турбо Паскаль, который,  в свою очередь, развился из  языка Паскаль. Паскаль был  полностью процедурным языком, Турбо  Паскаль, начиная с версии 5.5, добавил в Паскаль объектно-ориентированные свойства, а Delphi — объектно-ориентированный язык программирования с возможностью доступа к метаданным классов. Delphi оказал огромное влияние на создание концепции языка C# для платформы .NET. Многие его элементы и концептуальные решения вошли в состав С#. Мы будем рассматривать концепцию данных на основе среды версии Delphi 5. Delphi 5 имеет высокую производительность для развития Интернет. Представлено множество новых функций и усовершенствований. Некоторые из них, среди многих других, являются: различные макеты рабочего стола, концепция кадров, параллельное развитие, перевод возможности, более интегрированный отладчик, новые возможности Интернет (XML), базы данных ADO.

Интегрированная среда разработки Delphi - это среда, в которой есть все необходимое для проектирования, запуска и тестирования создаваемых приложений. Большинство версий Delphi выпускается в нескольких вариантах: а) стандартная, б) профессиональная версия, в) разработка баз данных предметных областей. Эти варианты различаются, в основном разным уровнем доступа к системам управления базами данных. Последние два варианта являются наиболее мощными в этом отношении. Библиотеки компонентов в различных вариантах практически одинаковы. В Delphi используется язык Object Pascal, который постоянно расширяется и дополняется Borland. Язык в полной мере поддерживает все требования, предъявляемые к объектно-ориентированному языку программирования.

Любые данные, т.е. константы, переменные, свойства, значения функций или выражения  характеризуются своими типами. Тип  определяет множество допустимых значений, которые может иметь тот или иной объект, а также множество допустимых операций, которые применимы к нему. Кроме того, тип определяет также и формат внутреннего представления данных в памяти ПК.

Вообще язык Object Pascal характеризуется  разветвленной структурой типов данных (рис.1) . В языке предусмотрен механизм создания новых типов, благодаря чему общее количество используемых в программе типов может быть сколь угодно большим.

Рис. 1Типы данных в Delphi

Характерной особенностью среды Delphi является возможность использования в ней не только собственных типов, но и типов из общей системы типов – CTS(Common Type System). CTS определяет возможность взаимодействия программ и их частей, написанных на разных языках программирования. Фактически все собственные типы Delphi проецируются на соответствующие типы CTS, потому что их и только их способна обрабатывать общеязыковая среда исполнения(CLR). Каждый компилятор, вырабатывающий инструкции, должен частично или полностью использовать CTS, и никакие другие типы данных, кроме указанных в CTS.Набор перечисленных в CTS типов значительно превышает количество типов в реально существующих языках программирования.

Common Type System (сокр. CTS, русск. Стандартная система типов) — формальная спецификация, определяющая, как какой-либо тип (класс, интерфейс, структура, встроенный тип данных) должен быть определён для его правильного выполнения средой .NET. Кроме того, данный стандарт определяет, как определения типов и специальные значения типов представлены в компьютерной памяти. Целью разработки CTS было обеспечение возможности программам, написанным на различных языках программирования, легко обмениваться информацией.

Функции Common Type System:

• Формирует фреймворк, способствующий межъязыковой интеграции, безопасности типов, а также высокой производительности исполнения кода.
• Обеспечивает объектно-ориентированную модель, поддерживающую полную реализацию множества языков программирования.
• Определяет правила, которым должны следовать языки, что в том числе позволяет гарантировать, что объекты, написанные на разных языках, могут друг с другом взаимодействовать.
• CTS определяет правила, гарантирующие, что типы данных объектов, написанные на разных языках, смогут взаимодействовать друг с другом.
• CTS определяет правила для видимости типов и доступа к членам типа, то есть CTS утверждает правила, по которым сборки формируют области видимости для типа.
• CTS определяет правила, управляющие наследованием типов, виртуальными методами и продолжительностью существования объектов.
• Языки, поддерживаемые платформой .NET, могут реализовывать все или некоторые из общих типов данных.

Спецификация для CTS закреплена в стандарте Ecma 335.

Данные, независимо от типа, имеют некоторое значение и в программе предстают как константы или переменные. Данные, которые получили значение в начале программы и по своей природе изменяться не могут, называются константами. Константами, например, являются скорость света в вакууме и соотношение единиц измерения (метр, сантиметр, ярд, фут, дюйм), которые имеют научно обоснованные или традиционно принятые постоянные значения. Константы описываются с помощью зарезервированного слова const. За ним идет список имен констант, каждому из которых с помощью знака равенства присваивается значение. Одно присваивание отделяется от другого с помощью точки с запятой. Тип константы распознается компилятором автоматически, поэтому его не надо указывать при описании. Примеры констант:

const

DelphiLanguage = 'Object Pascal';

KylixLanguage = DelphiLanguage;

Yard = 914.4;

Foot = 304.8;

После такого описания для  обращения к нужному значению достаточно указать лишь имя соответствующей  константы.

Значение константы можно задавать и выражением. Например:

const

SecondsInMinute = 60;

SecondsInHour = SecondsInMinute * 60;

SecondsInDay = SecondsInHour * 24;

При объявлении константы  можно указать ее тип:

const

Percent: Double = 0.15;

FileName: string = 'HELP.TXT';

Переменные в отличие  от констант могут неограниченное число раз менять свое значение в процессе работы программы. Если в начале программы некоторая переменная X имела значение 0, то в конце программы X может принять значение 10000. Так бывает, например, при суммировании введенных с клавиатуры чисел.

Переменные описываются с помощью зарезервированного слова var. За ним перечисляются идентификаторы переменных, и через двоеточие указывается их тип. Каждая группа переменных отделяется от другой группы точкой с запятой. Например:

var

Index: Integer; //  переменная целого типа данных

FileName: string; //  переменная строкового типа данных

Sum, Profit: Double; // группа переменных вещественного типа данных

В теле программы переменной можно  присвоить значение. Для этого  используется составной символ :=, например:

Sum := 5000.0;// переменной Sum присваивается 5000

Percent := 0.15;// переменной Percent присваивается 0.15

Profit := Sum * Percent; // вычисляется произведение двух переменных

// и его результат присваивается переменной Profit

Вы можете присвоить  значение переменной непосредственно при объявлении:

var

Index: Integer = 1;

Delimiter: Char = ';';

Объявленные таким образом  переменные называются инициализированными. На инициализированные переменные накладывается  ограничение: они не могут объявляться  в подпрограммах (процедурах и функциях). Если переменная не инициализируется при объявлении, то по умолчанию она заполняется нулем.

Каждый используемый в программе элемент данных должен быть описан в разделе const или var. Исключение составляют данные, заданные непосредственно значением, например:

Write(100, 200); // 100 и 200 - данные, заданные значением

Тип определяет множество значений, которые могут принимать элементы данных, и совокупность допустимых над ними операций.

С помощью типов данных программист указывает компилятору, как хранить информацию в программе. При объявлении переменной необходимо указать ее тип. Одни типы уже определены в языке, другие программисту приходится задавать самому. В ранних языках программирования допускалось ограниченное число типов данных, и Pascal оказался одним из первых языков, допускающих определение в программе новых типов.

Типы данных, определяемые пользователем, обычно задаются в разделе  определения типов программы  или модуля (unit), однако это можно  делать и внутри процедур или функции. Объявления типов действуют в пределах того блока, в котором они размещены. Вне этого блока ссылаться на такие типы нельзя. Внутри же они заменяют все внешние типы с тем же именем. Объявленные типы данных можно применять в любом месте области их видимости; запрещена только ссылка определяемого типа на самого себя (тут, однако, есть одно исключение, касающееся указателей).

Объявления типов в Pascal являются для компилятора чем - то вроде схем, которые он должен запомнить на случай, если вдруг встретит в программе ссылки на тот или иной тип. Само по себе объявление типа не вносит в программу никаких изменений.

Что же касается объявлений var, то они задают компилятору некоторые  действия, связанные с ранее объявленными типами. Тип переменной ограничивает как ее значения, так и операции, которые можно выполнять с этими значениями.

Определения типов и  переменных могут размещаться в  нескольких местах компонентов программы.

Далее более подробно рассмотрим описание всех типов.

 

1. ОБЩАЯ СИСТЕМА ТИПОВ

Все типы CTS делятся на две группы: значимые и ссылочные.

Значимые типы являются контейнерами двоичных значений. Например, к значимым относится логический тип, имеющий два возможных значения — ноль и не ноль. Значимым является и тип Char, имеющий значения в диапазоне от О до 65 535. Этот тип кодирует символы Unicode. Подавляющее большинство значимых типов предопределено в конкретном языке программирования (в том числе в Delphi). К значимым относятся также и некоторые типы, определенные программистом, — например, перечисления. Значения значимых типов распределяются в локальной памяти программы, в том числе в стеке.

Ссылочные типы содержат указатели на данные, размещенные в памяти компьютера. Они распределяются в общей памяти (в куче). Ссылочные типы бывают самоописываемыми (self-describing), указателями и интерфейсами. Самоописываемые типы, в свою очередь, делятся на классы и массивы (рис. 2).

Рис. 2 Схема общей системы типов

Переменные значимых типов имеют собственную копию  данных, и действия над одной переменной относятся только к этой копии. Действия над переменными ссылочных типов относятся к некоторым объектам и могут влиять сразу на несколько ссылочных переменных. Пусть, например, имеются две переменные значимого типа (Int1 и Int2) и две — ссылочного (Ref1 и Ref2). Следующий пример иллюстрирует изменение их значений:

program CTS;

{$APPTYPE CONSOLE}

uses SysUtils;

type

Int = class

I: Integer;

end;

var

Int1, Int2: Integer; // Переменные значимого типа

Ref1,  Ref2:  Int; // Переменные ссылочного типа

begin

Int1 := 0;

Int2 := 123;

Ref1 := Int.Create;

Ref2 := Refl; // Обе ссылочные переменные

// указывают на один объект

Ref1.I := 234; // изменение одного изменяет другой

Writeln(Format('Int1=%d Int2=%d',[Int1,Int2]));

Writeln(Format('Ref1=%d Ref2=%d',[Ref1.I,Ref2.I]));

Readln

end.

На экран будут выведены следующие строки:

Int1 = 0 Int2 = 123

Ref1 = 234 Ref2 = 234

Для форматирования вывода используется функция Format.

Каждое значение относится к определенному типу. Значения самоописываемых типов называются объектами. В предыдущих версиях Delphi объектами обычно назывались экземпляры (значения) классов. В Delphi 2005 к объектам относятся также и значения массивов. В то время как по значению самоописываемого типа можно точно определить сам тип, этого нельзя сделать в отношении значений значимых типов и указателей.

Контейнером, определяющим границы видимости типов, в .NET Framework являются сборки (assembly). В Delphi роль сборок играют модули. Таким образом, два одноименных типа, описанные в разных сборках (модулях), — это разные типы. Имя типа в CLR имеет две логические части: имя сборки (модуля) и имя типа, разделенные точкой.

 

2. ПРОСТЫЕ ТИПЫ

К простым типам относятся порядковые типы, вещественные типы и тип дата - время. Все они в иерархии CTS относятся к значимым.

Порядковые типы отличаются тем, что каждый из них имеет конечное количество возможных значений. Эти значения можно определенным образом упорядочить (отсюда — название типов), и, следовательно, каждому из них можно сопоставить некоторое целое число — порядковый номер значения.

Вещественные типы, строго говоря, тоже имеют конечное количество значений, которое определяется форматом внутреннего представления вещественного числа. Однако это количество настолько велико, что сопоставить каждому из них целое число (его номер) не представляется возможным.

Тип дата-время предназначен для хранения даты и времени. Фактически для этих целей в нем используется вещественный формат.

1. Порядковые типы

К порядковым типам относятся (см. рис. 1.) целые, логические, символьный, перечисляемый и тип-диапазон. К любому из них применима функция Ord(x), которая возвращает порядковый номер значения выражения X.

Для целых типов функция ord(x) возвращает само значение х, т. е. Ord(X) = х для х, принадлежащего любому целому типу. Применение Ord(x) к логическому, символьному и перечисляемому типам дает положительное целое число в диапазоне от 0 до 1 (логический тип), от 0 до 255 (символьный), от 0 до 65535 (перечисляемый). Тип-диапазон сохраняет все свойства базового порядкового типа, поэтому результат применения к нему функции ord(х) зависит от свойств этого типа.

К порядковым типам можно  также применять функции:

pred(x) - возвращает предыдущее значение порядкового типа (значение, которое соответствует порядковому номеру ord (х) -1, т. е. оrd(рred(х)) = оrd(х) - 1;

succ (х) - возвращает следующее значение порядкового типа, которое соответствует порядковому номеру ord (х) +1, т. е. оrd(Succ(х)) = оrd(х) + 1.

Например, если в программе  определена переменная

var

с : Char;

begin

с := '5';

end;

то функция pred(с) вернет символ '4', а функция succ(с) - символ '6'.

Если представить себе любой порядковый тип как упорядоченное  множество значений, возрастающих слева  направо и занимающих на числовой оси некоторый отрезок, то функция pred(x) не определена для левого, a succ (х) - для правого конца этого отрезка.

1. Целые типы

Диапазон возможных  значений целых типов зависит  от их внутреннего представления, которое  может занимать один, два, четыре или восемь байтов. Далее приводятся названия целых типов, длина их внутреннего представления в байтах и диапазон возможных значений (табл. 2.1).

Таблица 2.1

Целые типы

Название	Длина, байт	Диапазон значений
Byte	1	0…255
ShortInt	1	-128…+127
SmallInt	2	-32 768…+32 767
Word	2	0…65 535
Integer	4	-2 147 483 648…+2 147 483 647
LongInt	4	-2 147 483 648…+2 147 483 647
LongWord	4	0…4 294 967 295
Int64	8	-9*1018…+9*1018
Cardinal	4	0…2 147 483 647

 

Данная таблица соответствует  целым типам в Delphi 5.Типы LongWord и Int64 впервые введены в версии 4, а типы Smallint и Cardinal отсутствуют в Delphi 1. Тип Integer для этой версии(Delphi 2005) занимает 2 байта и имеет диапазон значений от -32768 до +32767, т. е. совпадает с Smallint.

При использовании процедур и функций с целочисленными параметрами следует руководствоваться “вложенностью” типов, т.е. везде, где может использоваться Word, допускается использование Byte (но не наоборот), в Longint “входит” Smallint, который, в свою очередь, включает в себя Shortint.

Перечень процедур и  функций, применимых к целочисленным типам (реализация Delphi 5), приведен в табл. 2.2. Буквами b, s, w, i, l обозначены выражения соответственно типа Byte, Shortint, Word, Integer и Longint соответственно, буквой х - выражение любого из этих типов; буквы vb, vs, vw, vi, vl, vx обозначают переменные соответствующих типов. В квадратных скобках указывается необязательный параметр.

Таблица 2.2

Стандартные процедуры  и функции, применимые к целым  типам

Обращение	Тип результата	Действие
abs(x)	x	Возвращает модуль x
chr(b)	Char	Возвращает символ по его коду
dec (vx[ ,I])	_	Уменьшает значение vx на i, а при отсутствии i- на 1
inc (vx[ ,I])	_	Увеличивает значение vx на i, а при отсутствии i- на 1
Hi(w)	Byte	Возвращает старший  байт аргумента
Hi(I)	Byte	Возвращает третий по счёту байт
Lo(i)	Byte	Возвращает младший  байт аргумента
Lo(w)	Byte	Возвращает младший  байт аргумента
odd(l)	Boolean	Возвращает True, если аргумент - нечётное число
Random(w)	Как у параметра	Возвращает псевдослучайное  число, равномерно распределённое в  диапазоне 0…(w-1)
sqr(x)	X	Возвращает квадрат  аргумента
swap(i)	Integer	Меняет местами байты  в слове
swap(w)	Word	Меняет местами байты  в слове

При действиях с целыми числами тип результата будет  соответствовать типу операндов, а  если операнды относятся к различным целым типам - общему типу, который включает в себя оба операнда. Например, при действиях с Shortint и Word общим будет тип Integer. В стандартной настройке компилятор Delphi не вырабатывает код, осуществляющий контроль за возможной проверкой выхода значения из допустимого диапазона, что может привести к недоразумениям. Например, при прогоне следующей программы на экране появится значение 0:

procedure TfmExample. bbrunClick(Sender: TObject);

var

k:Word;

begin

k:= 65535; // Максимальное значение типаWord

k:= k+1; // По правилам математики k=65536

Writeln(k); // На самом деле  k=0!

Readln

end;

(приложение 1)

Если на вкладке Compiler диалогового окна Options (открывается командой Project ► Options) установить флажок Range checking и повторить компиляцию командой Project ► Build All, компилятор вставит в программу код проверки переполнения и при прогоне программы возникнет исключительная ситуация, которую при желании можно соответствующим образом обработать. Замечу, что можно изменить программу следующим образом:

k := 65535; // Максимальное значение типа Word

Writeln(k + 1); // Будет выведено 65536

Тогда переполнения не произойдет, так как 32-разрядный компилятор Delphi автоматически преобразует операнды выражения k + 1 к 4-байтным величинам.

2. Логические типы

К логическим относятся типы Boolean, ByteBool, Bool, WordBool и LongBool. В стандартном Паскале определен только тип Boolean, остальные логические типы введены в Object Pascal для совместимости с Windows: типы Boolean и ByteBool занимают по одному байту каждый, Bool и WordBool - по 2 байта, LongBool - 4 байта. Значениями логического типа может быть одна из предварительно объявленных констант False (ложь) или True (истина).

Поскольку логический тип  относится к порядковым типам, его можно использовать в операторе цикла счетного типа. В Delphi 5 для Boolean значение

Ord (True) = +1, в то время  как для других типов (Bool, WordBool и т.д.)

Ord (True) = -1, поэтому такого  рода операторы следует использовать  с осторожностью! Например, для версии Delphi 6 исполняемый оператор showMessage (' --- ') в следующем цикле for не будет выполнен ни разу:

var

L: Bool;

k: Integer;

begin

for L:= False to True do

ShowMessage ('---');

end;

(приложение 2)

Если заменить тип  параметра цикла L в предыдущем примере на Boolean, цикл будет работать и сообщение дважды появится на экране.

В отличии от некоторых  других языков, Object Pascal не позволяет трактовать целое значение как булеву величину. Поэтому, например, если X- целая переменная, то оператор

if X then…

будет воспринят компилятором как синтаксическая ошибка.

Для булевых типов  определены операции and (И), or (ИЛИ), not (НЕ, отрицание) и xor (исключающее ИЛИ) (табл. 2.3). Использование этих операций расширяет возможности по формированию сложных условий в ряде операторов.

Булевы операции принимают операнды булевых типов и возвращают результат тоже булевого типа.

Таблица 2.3

Булевы операции

Обозначение	Операция	Типы операндов	Тип результата	Пример
not	Отрицание	Boolean	Boolean	not (C in MySet)
and	Логическое И	Boolean	Boolean	Done and (Total > 0)
or	Логическое ИЛИ	Boolean	Boolean	A or B
xor	Логическое исключающее  ИЛИ	Boolean	Boolean	A xor B

3. Символьный тип

Для символов имеются  физические и общий типы. Физические типы представлены типами AnsiChar и WideChar. Символ типа AnsiChar занимает 1 байт, а для кодирования символов используется код ANSI (назван по имени American National Standard Institute - американского института стандартизации, предложившего этот код). Символ типа WideChar занимает 2 байта.

Каждому символу приписывается  целое число в диапазоне 0...255. Это число служит кодом внутреннего  представления символа, его возвращает функция ord.

Кроме физических типов, в языке Delphi определён общий тип Char, который эквивалентен типу AnsiChar.

Существуют символы, которые относятся к служебным кодам. Если эти коды используются в символьном тексте программы, они считаются пробелами.

К символьному типу применимы операции отношения, а также имеются следующие функции:

Сhr (W): Char – возвращает символ с кодом, равным значению целочисленного выражения x;

UpCase(C): Char – преобразует символ с к верхнему регистру;

А также предопределены такие функции  и процедуры, как Ord, Pred, Succ, Inc, Dec и др. Функция, возвращающая  номер символа, противоположна по смыслу функции Chr, т.е. Ord(Chr(65)) вернёт 65, а Chr(Ord(‘A’)) вернёт символ «А».

Например:

uses

SysUtils;

var d:char;

begin

ReadLn(d);

WriteLn(Ord(d)); //используем функцию, которая возвращает код символа

ReadLn(d);  //выводим код символа

end.

В результате получается код, значение которого зависит от введённого символа.

(приложение 3)

4. Перечисленный тип

Перечисленный тип задается перечислением тех значений, которые он может получать. Каждое значение именуется некоторым идентификатором и располагается в списке, обрамленном круглыми скобками.

Формат описания перечислимого  типа:

Type <Имя типа > = (<Имя 1>, …, <Имя N>);

Например:

type

colors = (red, white, blue);

Применение перечисляемых типов делает программы нагляднее. Если, например, в программе используются данные, связанные с месяцами года. То такой фрагмент программы был бы весьма наглядным:

type

ТипМесяц=(янв, фев, мар, апр, май, июн, июл, авг, сен, окт, ноя, дек);

var

месяц : ТипМесяц;

begin

…

if месяц = авг then

lbOutput.Caption:= 'Хорошо бы поехать к морю!';

…

end.

Приведём пример использования перечисленного типа, который содержит 3 имени и с помощью конструкций if и case of отображает сообщения в зависимости от того чему равна переменная xMonth:

uses

SysUtils;

type

Month = (Jan,Feb,Mar); //создаём перечисленный тип с тремя именами

var

xMonth : Month;   //создаём переменную перечисленного типа

ch:char;

i:integer;

begin

ReadLn(i);

Case i of

1: xMonth:=Jan;

2: xMonth:=Feb;

3: xMonth:=Mar;

end;

if xMonth=Jan

then WriteLn('Nachalo zimi');

if xMonth=Feb

then Writeln('Konec zimi');

if xMonth=Mar

then Writeln('Nachalo vesni');

ReadLn(ch);

end.

(приложение 4)

Соответствие между  значениями перечисляемого типа и порядковыми номерами этих значений устанавливается порядком перечисления: первое значение в списке получает порядковый номер 0, второе - 1 и т. д. Максимальная мощность перечисляемого типа составляет 65536 значений, поэтому фактически перечисляемый тип задает некоторое подмножество целого типа Word и может рассматриваться как компактное объявление сразу группы целочисленных констант со значениями 0, 1 и т. д.

Использование перечисляемых  типов повышает надежность программ благодаря возможности контроля тех значений, которые получают соответствующие переменные. Пусть, например, заданы такие перечисленные типы:

type

colors = (black, red, white);

ordenal = (one, two, three);

days = (Mon, Tue, Wed);

С точки зрения мощности и внутреннего  представления все три типа эквивалентны. Однако пусть определены такие переменные:

var

col : colors;

num : ordenal;

day : days;

Тогда допустимы следующие операторы:

col :=black;

num :=two;

day :=Tue;

В то же время следующие операторы  недопустимы:

col :=one;

day :=black;

Между значениями перечисленного типа и множеством целых чисел  существует однозначное соответствие.

В Object Pascal допускается  обратное преобразование: любое выражение  типа Word можно преобразовать в значение перечисляемого типа, если только значение целочисленного выражения не превышает мощности этого типа. Такое преобразование достигается применением автоматически объявляемой функции с именем перечисленноого типа. Например, для рассмотренного ранее объявления типов эквивалентны следующие присваивания: