Real — Тип Delphi

Real — Тип Delphi

Программа, представленная в виде инструкций языка программирования, называется исходной программой. Она состоит из инструкций, понятных человеку, но не понятных процессору компьютера. Чтобы процессор смог выполнить работу в соответствии с инструкциями исходной программы, исходная программа должна быть переведена на машинный язык — язык команд процессора. Задачу преобразования исходной программы в машинный код выполняет специальная программа — компилятор.

Компилятор, схема работы которого приведена на рис. 1.4, выполняет последовательно две задачи:

1. Проверяет текст исходной программы на отсутствие синтаксических ошибок.

2. Создает (генерирует) исполняемую программу — машинный код.

Рис. 1.4. Схема работы компилятора

Следует отметить, что генерация исполняемой программы происходит только в том случае, если в тексте исходной программы нет синтаксических ошибок.

Генерация машинного кода компилятором свидетельствует лишь о том, что в тексте программы нет синтаксических ошибок. Убедиться, что программа работает правильно можно только в процессе ее тестирования — пробных запусках программы и анализе полученных результатов. Например, если в программе вычисления корней квадратного уравнения допущена ошибка в выражении (формуле) вычисления дискриминанта, то, даже если это выражение будет синтаксически верно, программа выдаст неверные значения корней.

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

Каждая инструкция состоит из идентификаторов. Идентификатор может обозначать:

• Инструкцию языка (:=, if, while, for);
• переменную;
• константу (целое или дробное число);
• арифметическую (+, -,*,/) или логическую (and, or, not) операцию;
• подпрограмму (процедуру или функцию);
• отмечать начало (procedure, function) или конец (end) подпрограммы ИЛИ блока (begin, end).

Программа может оперировать данными различных типов: целыми и дробными числами, символами, строками символов, логическими величинами.

Язык Delphi поддерживает семь целых типов данных: shortint, smailint, Longint, Int64, Byte, word и Longword, описание которых приведено в табл. 1.1.

Таблица 1.1. Целые типы

-2 147 483 648 — 2 147 483 647

8 битов, беззнаковый

16 битов, беззнаковый

0 — 4 294 967 295

32 бита, беззнаковый

Object Pascal поддерживает и наиболее универсальный целый тип — Integer, который Эквивалентен Longint.

Язык Delphi поддерживает шесть вещественных типов: Reai48, single, Double, Extended, comp, Currency. Типы различаются между собой диапазо-ном допустимых значений, количеством значащих цифр и количеством байтов, необходимых для хранения данных в памяти компьютера (табл. 1.2).

Таблица 1.2. Вещественные (дробные) типы

2.9x 10 -39 -1.7×10 38

1.5 x 10 -45 -3.4х 10 38

5.0×10- 324 -1.7×10 308

3.6×10- 4951 -1.1 х10 4932

-922 337 203 685 477.5808 —922 337 203 685 477.5807

Язык Delphi поддерживает и наиболее универсальный вещественный тип — Real, который эквивалентен Double.

Язык Delphi поддерживает два символьных типа: Ansichar и Widechar:

• тип Ansichar — это символы в кодировке ANSI, которым соответствуют числа в диапазоне от 0 до 255;
• тип widechar — это символы в кодировке Unicode, им соответствуют числа от 0 до 65 535.

Object Pascal поддерживает и наиболее универсальный символьный тип — Char, который эквивалентен Ansichar.

Язык Delphi поддерживает три строковых типа: shortstring, Longstring, WideString:

• тип shortstring представляет собой статически размещаемые в памяти компьютера строки длиной от 0 до 255 символов;
• тип Longstring представляет собой динамически размещаемые в памяти строки, длина которых ограничена только объемом свободной памяти;
• тип WideString представляет собой динамически размещаемые в памяти строки, длина которых ограничена только объемом свободной памяти. Каждый символ строки типа WideString является Unicode-символом.

В языке Delphi для обозначения строкового типа допускается использование идентификатора string. Тип string эквивалентен типу shortstring.

Логическая величина может принимать одно из двух значений True (истина) или False (ложь). В языке Delphi логические величины относят к типу Boolean.

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

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

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

Следует обратить внимание на то, что компилятор языка Delphi не различает прописные и строчные буквы в именах переменных, поэтому имена SUMMA, Summa и summa обозначают одну и ту же переменную.

Желательно, чтобы имя переменной было логически связано с ее назначением. Например, переменным, предназначенным для хранения коэффициентов и корней квадратного уравнения, которое в общем виде традиционно записывают

вполне логично присвоить имена а, b, с, x1 и х2. Другой пример. Если в программе есть переменные, предназначенные для хранения суммы покупки и величины скидки, то этим переменным можно присвоить имена

TotalSumm и Discount или ObSumma и Skidka.

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

В общем виде инструкция объявления переменной выглядит так:

• имя — имя переменной;
• тип — тип данных, для хранения которых предназначена переменная.

а : Real; b : Real; i : Integer;

В приведенных примерах объявлены две переменные типа real и одна переменная типа integer.

В тексте программы объявление каждой переменной, как правило, помещают на отдельной строке.

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

а,b,с : Real; x1,x2 : Real;

В языке Delphi существует два вида констант: обычные и именованные.

Обычная константа — это целое или дробное число, строка символов или отдельный символ, логическое значение.

Real — Тип Delphi

Продолжаем наше обучение! В Delphi очень важную роль играют переменные. В процессе работы программы в переменных можно как хранить так и извлекать информацию. Переменные могут иметь разный тип. Например для того, чтобы в переменную записать какой-нибудь текст используется тип String. Для того, что бы записать в переменную число используют тип Integer.

Вот список основных типов переменных в Delphi:

• Integer — целые числа из диапазона: -2147483648..+2147483647
• Shortin — целые числа из диапазона: -128..+127
• Byte — целые числа из диапазона: 0..+255
• Real — как целые так и дробные числа из диапазона: 5e-324..1.7e+308
• Double — схож с типом Real
• String — строковый тип данных
• Char — символьный тип данных
• Bollean — логический тип данных. Может принимать значение True — истина или False — ложь

С теорией мы закончили, теперь давайте откроем Delphi 7 и создадим новый проект. После этого кидаем на форму знакомый нам компонент Button и еще не знакомый Label. Компонент Label эта такая полезная вещь, в которую можно записать какую-нибудь подпись. Например подпись для другого компонента или просто записать в него автора программы. Попробуйте отыскать компонент Label сами, наводя на все компоненты в вкладке Standard и читая всплывающую подсказку. Кому сложно найти, то это четвертый компонент слева, не считая значка курсора.

Я всё сделал и у меня получилось вот так:

Сейчас нам нужно создать событие OnClick на кнопке, я надеюсь, что вы помните, как это делать.
Переменные объявляются между ключевыми словами procedure и begin. Объявление начинается с ключевого слова var, потом пишется имя переменной и через двоеточие её тип. Заканчивается все как всегда точкой с запятой.

Создадим переменную S типа String в процедуре OnClick: После этого между ключевыми словами begin end присвоим переменной значение равное ‘Моя первая переменная’. Присвоение пишется следующим образом. Пишем имя переменной, оператор присвоения := и значение. Если мы записываем информацию типа String, то информация заключается в одинарные кавычки.

Общий вид: Теперь если скомпилировать программу и нажать на кнопку ничего существенного не произойдет, просто в переменную запишется значение и всё. Попробуем вывести значение из переменной. Делается это также просто как и записывается. Выводить значение мы будем в наш Label.

Синтаксис такой: Разберем этот код подробно. Сначала мы написали Label1, потом пишем точку и в Delphi появляется огромный список со свойствами данного компонента. Можно конечно порыться и отыскать там Caption, но мы будем умнее! Мы, после того как поставили точку, напишем еще букву C и Delphi как бы отсортирует все свойства и найдет все, которые начинаются с буквы C. Первым в списке как раз будет свойство Caption.

Выбираем его из списка и нажимаем на Enter. Заметьте, что мы писали Label1.C, но после того, как нажали Enter, Delphi сам дописал название свойства. Далее опять же идет оператор присвоения и наша переменная.

Вы наверняка спросите: «Зачем же переменная, если можно было написать Label1.Caption:=’Моя первая переменная’;?». Ответ простой. Это нужно затем, что мы изучаем переменные :).
Нет, на самом деле так присваивать тоже можно, но представьте такую ситуацию, что вы написали очень большую, популярную программу и у вас, там в программе, пятидесяти компонентам присваивается одно и тоже значение и вот перед вами встала задача: «Поменять это значение на более универсальное и понятное для пользователя».

Что вы будете делать?

• В первом случае у вас всем этим компонентам присваивается одна и та же переменная и чтобы изменить всем этим пятидесяти компонентам значение вам просто нужно поменять значение в переменной.
• Во втором случае вы сидите 20 минут и всё копируете и копируете значение всем пятидесяти компонентам.

Вывод делайте сами.

И так, продолжаем! В общем виде должно быть так: Компилируем нашу программу и нажимаем на Button (батон/кнопку). Сразу же компонент Label вместо Label1 будет показывать Моя первая переменная.

На этом хотелось бы закончить, так как я уже устал писать урок :), но я еще не познакомил вас с типом Integer и как присваивать переменную с таким типом. Вы думаете, что присваивать ее нужно точно так же как и переменную типа String, но вы ошибаетесь.
Дело в том, что свойству Caption вообще у всех компонентов можно присвоить только текстовые значения. Как мы будем присваивать числовой тип если можно только текстовой? Всё проще некуда. Между типами переменных можно как бы переключаться, то есть можно из числового типа сделать текстовой и присвоить его компоненту Label. Этим мы сейчас и займемся.

Для начала нужно начать сначала :). Объявим переменную с именем I и типом Integer, дописав ее к переменной S. Код: Далее присвоим переменной I значение 21. Заметьте, что числовое значение записывается без одинарных кавычек! Теперь присвоим свойству Caption значение переменной I, для этого нужно воспользоваться оператором IntToStr(). Он как бы конвертирует числовой тип в текстовой. В скобках указывается переменная, которую нужно конвертировать.

Общий вид кода: Скомпилируйте программу и вы увидите, что Label будет отображать значение переменной I, то есть 21.

Ну вот и всё! Удачи!
Встретимся в следующем уроке!

Источник: www.thedelphi.ru
Автор: Савельев Александр
Опубликовано: 22 Апреля 2012
Просмотров:

Зарегистрируйтесь или авторизуйтесь, чтобы добавлять комментарии.

В Delphi как определить, когда использовать Real, Real48, двойной или одинарной типы данных?

Большинство моих приложений вращается вокруг финансовых расчетов, связанных платежи и расчеты процентных ставок. Я ищу, чтобы узнать, как определить, что Delphi тип данных лучше всего использовать.

Если я использую базу данных для хранения этих значений и я определил поля в этой базе данных, чтобы быть десятичным значением с двумя знаками после запятой, что Delphi типа данных является наиболее совместимым с этим сценарием?

Должен ли я использовать округление формулы в Delphi для форматирования результатов до двух знаков после запятой перед сохранением значения в базе данных? Если это так, что это лучшая практика для этого?

Для таких расчетов, не используют плавающие типы точек, как Real, Single или Double. Они не очень хорошо с десятичными значениями, как 0,01 или 1234.995, так как они должны приблизить их.

Вы можете использовать валюту, тип с фиксированной точкой, но по-прежнему ограничивается до 4 знаков после запятой.

Попробуйте мой Десятичный тип, в котором 28-29 места и имеет десятичный показатель поэтому он идеально подходит для таких расчетов. Единственным недостатком является то, что она не поддерживается FPU (но написана на ассемблере, тем не менее) , так что это не так быстро , как встроенных типов. Это так же , как десятичного типа , который используется в .NET (но немного быстрее) и очень похож на тот , используемый на Mac.

Если вы хотите сделать финансовые расчеты, не используют какой-либо из чисел с плавающей точкой / вещественных типов. Delphi имеет тип валюты, которая является значением фиксированной запятой с 4 знаков после запятой, что должно быть только то, что вам нужно.

Классификация типов данных в Delphi. Тип Real

Согласно стандартной классификации, типы данных бывают следующие:

Числовые. Хранятся числа. Могут применяться обычные арифметические операции.

Целочисленные: со знаком, то есть могут принимать как положительные, так и отрицательные значения; и без знака, то есть могут принимать только неотрицательные значения.

Вещественные: с фиксированной точкой, то есть хранятся знак и цифры целой и дробной частей и с плавающей точкой, то есть число приводится к виду m*2e, где m — мантисса, e — экспонента причем 1/2 -38 до 3,4 x 10 38 .

Тип Double(real) является общим типом с плавающей запятой в Delphi. Он подводит баланс между вместимость/точность и память/выполнение.

Он поддерживает приблизительно 15 цифр точности в диапазоне от 2.23 x 10 -308 до 1.79 x 10 308 .

Тип Extended является типом числа с плавающей запятой, используется когда требуются самая высокая точность и/или самая высокая экспонента.

Он поддерживает приблизительно 19 цифр точности в диапазоне от 3.37 x 10 -4932 до 1.18 x 10 4932

Дата добавления: 2015-02-16 ; просмотров: 14 | Нарушение авторских прав

Типы данных Delphi и работа с ними

К встроенным типам данных в языке Delphi относятся типы целые, действительные, символы, строки, указатели, булевы.

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

Структурные типы. К структурным типам относятся множества, массивы, записи, файлы, классы, интерфейсы.

Целые типы данных. В переменных целых типов информация представляется в виде целых чисел, т.е. чисел не имеющих дробной части.

Таблица 1 Операции над порядковыми типами

Минимальное значение порядкового типа Т

Максимальное значение порядкового типа Т

Порядковый номер значения выражения порядкового типа. Для целого выражения — просто его значение. Для остальных порядковых типов Ord возвращает физическое представление результата выражения, трактуемое как целое число. Возвращаемое значение всегда принадлежит одному из целых типов

Предыдущее по порядку значение. Для целых выражений эквивалентно Х-1

Следующее по порядку значение. Для целых выражений эквивалентно Х+1

Уменьшает значение переменной на 1. Эквивалентно V := Pred(V)

Увеличивает значение переменной на 1. Эквивалентно V := Succ(V)

8 битов, беззнаковый

16 битов, беззнаковый

32 бита, беззнаковый

Также существует такой тип, как Integer, который эквивалентен типу LongInt. Его диапазон от -2147483648 до 21474836478. Занимает 4 байта в пямяти. Основными являются Integer и Cardinal, так что в большинстве случаев желательно использовать эти типы.

Над целыми данными выполняются все операции, определенные для порядковых типов. Операции над целыми типами:

Возвращает абсолютное целое значение Х

Возвращает целую часть частного деления Х на Y

Возвращает остаток частного деления Х на Y

Возвращает булево True (истина), если Х — нечетное целое, и False (ложь) — в противном случае

Действительные типы данных. В переменных действительных типов содержатся числа, состоящие из целой и дробной частей.

Количество значащих цифр

Основным, обеспечивающим максимальную производительность, является тип Real, который в настоящий момент эквивалентен типу Double.

Таблица 5 Функции действительных типов

Абсолютная величина х

Косинус х (х выражается в радианах, а не в градусах)

Экспоненциальная функция от х

Дробная часть х

Целая часть х. Несмотря на название, возвращает действительное значение (с плавающей запятой), т.е. просто устанавливает нуль в дробной части

Натуральный логарифм от х

Ближайшее к х целое значение. Возвращает значение целого типа. Условие «ближайшее к х» не работает, если верхнее и нижнее значения оказываются равноудаленными (например, если дробная часть точно равна 0,5). В этих случаях Delphi перекладывает решение на операционную систему. Обычно процессоры Intel решают эту задачу в соответствии с рекомендацией IEEE округлять в сторону ближайшего четного целого числа. Иногда такой подход называют «банкирским округлением»

Квадрат х, т.е. X*X

Квадратный корень от х

Целая часть х. В отличие от Int, возвращающей

Символьные типы данных. Символьные типы предназначены для хранения одного символа.

Однобайтовые символы, упорядоченные в соответствии с расширенным набором символов ANSI

Символы объемом в слово, упорядоченные в соответствии с международным набором символов UNICODE. Первые 256 символов совпадают с символами ANSI

Булевы типы данных. Переменные булевых типов данных представляют логические значения, например, true (истина) и false (ложь).

Таблица 7 Размеры переменных булевых типов

2 байт (объем Word)

4 байт (объем Longint)

Массив — это структура данных, представляющая собой набор переменных одинакового типа, имеющих общее имя. Массивы удобно использовать для хранения однородной по своей природе информации, например, таблиц и списков.

Массив, как и любая переменная программы, перед использованием должен быть объявлен в разделе объявления переменных. В общем виде инструкция объявления массива выгладит следующим образом:

Имя: [нижний_индекс..верхний_индекс] of тип

где: имя — имя массива;

array — зарезервированное слово языка Delphi, обозначающее, что объявляемое имя является именем массива;

нижний_индекс и верхний_индекс — целые константы, определяющие диапазон изменения индекса элементов массива и, неявно, количество элементов (размер) массива;

Simple Types (Delphi)

Contents

Simple types — which include ordinal types and real types — define ordered sets of values.

Ordinal Types

Ordinal types include integer, character, Boolean, enumerated, and subrange types. An ordinal type defines an ordered set of values in which each value except the first has a unique predecessor and each value except the last has a unique successor. Further, each value has an ordinality, which determines the ordering of the type. In most cases, if a value has ordinality n, its predecessor has ordinality n-1 and its successor has ordinality n+1.

For integer types, the ordinality of a value is the value itself. Subrange types maintain the ordinalities of their base types. For other ordinal types, by default the first value has ordinality 0, the next value has ordinality 1, and so forth. The declaration of an enumerated type can explicitly override this default.

Several predefined functions operate on ordinal values and type identifiers. The most important of them are summarized below.

-2147483648..2147483647
(-2 31 ..2^ 31 -1)

-9223372036854775808..9223372036854775807
(-2 63 ..2 63 -1)

0..4294967295
(0..2 32 -1)

0..18446744073709551615
(0..2 64 -1)

-2147483648..2147483647
(-2 31 ..2 31 -1)

-9223372036854775808..9223372036854775807
(-2 63 ..2 63 -1)

0..4294967295
(0..2 32 -1)

0..18446744073709551615
(0..2 64 -1)

Note: 32-bit platforms include 32-bit Windows, 32-bit macOS, 32-bit iOS, iOS Simulator and Android.

Platform-Independent Integer Types

Platform-independent integer types always have the same size, regardless of what platform you use. Platform-independent integer types include ShortInt, SmallInt, LongInt, Integer, Int64, Byte, Word, LongWord, Cardinal, and UInt64.

Platform-independent integer types

A value of type ByteBool, LongBool, or WordBool is considered True when its ordinality is nonzero. If such a value appears in a context where a Boolean is expected, the compiler automatically converts any value of nonzero ordinality to True.

The previous remarks refer to the ordinality of Boolean values, not to the values themselves. In Delphi, Boolean expressions cannot be equated with integers or reals. Hence, if X is an integer variable, the statement:

generates a compilation error. Casting the variable to a Boolean type is unreliable, but each of the following alternatives will work.

Enumerated Types

An enumerated type defines an ordered set of values by simply listing identifiers that denote these values. The values have no inherent meaning. To declare an enumerated type, use the syntax:

where typeName and each val are valid identifiers. For example, the declaration:

defines an enumerated type called Suit , whose possible values are Club , Diamond , Heart , and Spade , where Ord(Club) returns 0, Ord(Diamond) returns 1, and so on.

When you declare an enumerated type, you are declaring each val to be a constant of type typeName . If the val identifiers are used for another purpose within the same scope, naming conflicts occur. For example, suppose you declare the type:

Unfortunately, Click is also the name of a method defined for TControl and all of the objects in VCL that descend from it. So if you are writing an application and you create an event handler like:

you will get a compilation error; the compiler interprets Click within the scope of the procedure as a reference to a Click method of a TForm. You can work around this by qualifying the identifier; thus, if TSound is declared in MyUnit, you would use:

A better solution, however, is to choose constant names that are not likely to conflict with other identifiers. Examples:

You can use the (val1, . valn) construction directly in variable declarations, as if it were a type name:

But if you declare MyCard this way, you cannot declare another variable within the same scope using these constant identifiers. Thus:

generates a compilation error. But:

compiles cleanly, as does:

Enumerated Types with Explicitly Assigned Ordinality

By default, the ordinalities of enumerated values start from 0 and follow the sequence in which their >

defines a type called Size whose possible values include Small , Medium , and Large , where Ord(Small) returns 5, Ord(Medium) returns 10, and Ord(Large) returns 15.

An enumerated type is, in effect, a subrange whose lowest and highest values correspond to the lowest and highest ordinalities of the constants in the declaration. In the previous example, the Size type has 11 possible values whose ordinalities range from 5 to 15. (Hence the type array[Size] of Char represents an array of 11 characters.) Only three of these values have names, but the others are accessible through typecasts and through routines such as Pred, Succ, Inc, and Dec. In the following example, «anonymous» values in the range of Size are assigned to the variable X .

Any value that is not explicitly assigned an ordinality has the ordinality one greater than that of the previous value in the list. If the first value is not assigned an ordinality, its ordinality is 0. Hence, given the declaration:

SomeEnum has only two possible values: Ord(e1) returns 0, Ord(e2) returns 1, and Ord(e3) also returns 1; because e2 and e3 have the same ordinality, they represent the same value.

Enumerated constants without a specific value have RTTI:

whereas enumerated constants with a specific value, such as the following, do not have RTTI:

Scoped Enumerations

You can use scoped enumerations in Delphi code if you enable the compiler directive.

For instance, let us define the following unit in the Unit1.pas file

and the following program using this unit

First, Run (F9) on this code. The code runs successfully. This means that the First identifier, used in the

variable, is the global scope identifier introduced in the

Now clear comment from the

compiler directive in the unit1 unit. This directive enforces the TMyEnum enumeration to be scoped. Execute Run. The E2003 Undeclared identifier ‘First’ error is generated on the

line. It informs that the <$SCOPEDENUMS ON>compiler directive prevents the First identifier, introduced in the scoped TMyEnum enumeration, to be added to the global scope.

To use identifiers introduced in scoped enumerations, prefix a reference to an enumeration’s element with its type name. For example, clear comment in the second

version of the Value variable (and comment the first version of Value ). Execute Run. The program runs successfully. This means that the First identifier is known in the TMyEnum scope.

Now comment the

compiler directive in unit1 . Then clear comment from the declaration of the First variable

and again use the

variable. Now the code in the program Project1 looks like this:

Execute Run. The

line causes the E2010 Incompatible types — ‘TMyEnum’ and ‘Integer’ error. This means that the naming conflict occurs between the global scope First identifier introduced in the TMyEnum enumeration and the First variable. You can work around this conflict by qualifying the First identifier with the unit1 unit in which it is defined. For this, comment again the first version of Value variable and clear comment from the third one:

Execute Run. The program runs successfully. That is, now the First identifier can be qualified with the unit1 unit scope. But what happens if we again enable the

compiler directive in unit1 . The compiler generates the E2003 Undeclared identifier ‘First’ error on the

line. This means that prevents adding the First enumeration’s identifier in the unit1 scope. Now the First identifier is added only in the TMyEnum enumeration’s scope. To check this, let us again use the

version of the Value variable. Execute Run and the code succeeds.

Subrange Types

A subrange type represents a subset of the values in another ordinal type (called the base type). Any construction of the form Low..High , where Low and High are constant expressions of the same ordinal type and Low is less than High , identifies a subrange type that includes all values between Low and High . For example, if you declare the enumerated type:

you can then define a subrange type like:

Here TMyColors includes the values Green , Yellow , Orange , Purple , and White .

You can use numeric constants and characters (string constants of length 1) to define subrange types:

When you use numeric or character constants to define a subrange, the base type is the smallest integer or character type that contains the specified range.

The LowerBound..UpperBound construction itself functions as a type name, so you can use it directly in variable declarations. For example:

declares an integer variable whose value can be anywhere in the range from 1 through 500.

The ordinality of each value in a subrange is preserved from the base type. (In the first example, if Color is a variable that holds the value Green , Ord(Color) returns 2 regardless of whether Color is of type TColors or TMyColors.) Values do not wrap around the beginning or end of a subrange, even if the base is an integer or character type; incrementing or decrementing past the boundary of a subrange simply converts the value to the base type. Hence, while:

produces an error, the following code:

assigns the value 100 to I (unless compiler range-checking is enabled).

The use of constant expressions in subrange definitions introduces a syntactic difficulty. In any type declaration, when the first meaningful character after = is a left parenthesis, the compiler assumes that an enumerated type is being defined. Hence the code:

produces an error. Work around this problem by rewriting the type declaration to avoid the leading parenthesis:

Real Types

A real type defines a set of numbers that can be represented with the floating-point notation. The table below gives the ranges and storage formats for the real types on 64-bit and 32-bit platforms.