Word delphi тип данных

Обновлено: 07.07.2024

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.7x10 38

1.5 x 10 -45 -3.4х 10 38

5.0x10- 324 -1.7x10 308

3.6x10- 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 существует два вида констант: обычные и именованные.

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

Числовые константы

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

Ниже приведены примеры числовых констант:

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

В табл. 1.3 приведены примеры чисел, записанных в обычной форме, в алгебраической форме и форме с плавающей точкой.

Andrew Fionik
дата публикации 09-04-2004 15:57

урок из цикла: Азы Delphi.

Итак, в предыдущей лекции мы примерно представили что из себя представляют типы данных и какие они бывают. В этой лекции мы более подробно разберем встроенные в Delphi типы данных.

Pascal, Object Pascal а за ними и Delphi всегда являлись строго типизированными языками, а это очень важное и полезное свойство языка. Когда для переменных определен тип данных к которому они принадлежат, компилятор имеет возможность проверить правильность операций производимых над этими переменными на этапе компиляции. Таким образом, компилятором производится как-бы первичное тестирование вашего кода. Однако, будучи языком строго типизированным, Delphi имеет механизмы позволяющие программисту определить "свои правила игры" и проинструктировать компилятор чтобы тот трактовал переменные не так, как положено их трактовать согласно их типу, а так, как указывает программист. Такой подход чем-то напоминает электрическую мясорубку. Запихивайте туда мясо согласно инструкции и она благополучно выплюнет фарш из которого ваша мамочка, жена или подруга нажарит вкуснючих котлет. Но если снимете предохранительный кожух и неловко дернетесь, то фарш будет из ваших пальцев.

Целочисленные типы данных

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

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

Вся масса целочисленных типов разделяется на две части - знаковые и беззнаковые типы данных. Знаковые типы данных позволяют хранить значения со знаком, точнее со знаком "-", т.е. отрицательные значения. Беззнаковые типы данных всегда хранят только значения больше или равно нулю.

Общие целочисленные типы

Integer

Тип данных Integer общий (generic) знаковый тип. Если помните предыдущую лекцию, то там объяснялось что общие типы данных - платформозависимые. Так вот и Integer на разных платформах имеет разный диапазон значений и занимает разный объем памяти, соответствующий одному машинному слову. На 32-ух разрядных системах Integer может содержать содержать значения от -2147483648 до 2147483647. Почему именно такой диапазон? Все очень просто, это минимальное и максимальные значения которые можно выразить (закодировать) 32-мя бинарными разрядами.Далее, когда снова попадется общий тип данных, я буду указывать его параметры именно для 32-ух разрядных систем. Какими они были на старых системах не очень-то и интересно, а какими они будут сами догадаетесь, не маленькие уже.

Cardinal

Общий (чуете что это значит?) беззнаковый тип. Может содержать значения от 0 до 4294967295.

Фундаментальные целочисленные типы

У прочих встроенных типов данных нет каких-либо особенностей, поэтому ниже я дам просто сводную таблицу в которой будут описаны эти типы данных.

Сводная таблица типов

Хранение целочисленных значений.
Различные математические вычисления.

Вещественные типы данных

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

NB! Тут следует обратить внимание на некоторые расхождения в терминологии. У нас считается что дробную часть от целой разделяет запятая. У "них" (америкосов) - точка. Соответственно по отношению к вещественным типам данных говорится floating point (плавающая точка) и fixed point (фиксированная точка). В частности в Delphi, для записи вещественных значений в тексте программы, используется именно точка а не запятая. Однако, внутренний формат записи вещественных чисел никак не относится к их представлению пред ясны очи пользователя у которого согласно давней доброй традиции целая часть от десятичной в его родной зимбабве может отделяться буквой "зю".

Для вещественных чисел с плавающей точкой данные хранятся в экспоненциальном формате. Т.е. хранятся мантисса и экспонента (не помню уже преподают это в школе или нет, но на всякий случай объясню). Например число 12345.6789 хранится в виде 1.23456789*10^4 (1.23456789 умножить на десять в степени 4). Мантисса это число 1.23456789 а экспонента это 4, то в какую степень возводится 10.
Вы спросите: "Что за тавтология!? Опять-же записываем десятичную дробь с помощью десятичной точки. Та же фигня только в профиль".
Отвечаю: "А компьютер про десятичную точку на самом деле ничего не знает, он просто хранит у себя 123456789 и 4 (упакованные конечно в бинарную форму, в один блок памяти фиксированного размера). И всегда считается что десятичная точка находится после первой цифры - в нашем случае между 1 и 2".

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

Пример. Пусть количество значащих цифр 7. Тогда записывая число 987654321 мы сможем записать только 7 цифр из этого числа для представления его в компьютере. Таким образом записать наше число сможем только в приблизительном виде: 9.876543E+8. Все последующие операции с этим значением будут выполнятся уже как с 987654300 а не как с 987654321. Попробуем прибавить к такому числу 1 и получим не 987654322 и не 987654301 а все то-же 987654300 т.к. результат все равно не может быть выражен таким ограниченным количеством значащих цифр.

Второе следствие такого способа хранения вещественных значений - особенности совместного хранения таких значений. Предположим что у нас есть два типа данных, один из которых позволяет хранить 7 значащих цифр а второй 12. Присвоим переменным этих типов значение 123456789. Значение одной переменной будет 1.234567E8 а второй 1.23456789E8. Т.е. получается что значения в этих переменных уже не равны, хотя мы и присваивали им одно и то-же значение.

Ну и третье следствие хранения вещественных значений - сравнение таких значений. Предположим что двумя разными путями вычислялась одна и та-же величина. В одном случае получился результат 1.234 в другом 1.235. Равны ли эти результаты? Вы скажете "нет" и будете правы. Скажете "да" и будете тоже правы. Вопрос состоит в том какая "степень равенства" нас удовлетворяет чтобы признать эти числа равными. Для определения равенства двух вещественных значений обычно используется не собственно результат их сравнения, а соотношение между их разностью и Epsilon - неким достаточно маленьким числом. Т.е. считается что два числа равны если модуль их разности не превышает Epsilon который мы задаем изначально и значение которого мы признаем достаточным чтобы обеспечить приемлемую точность наших расчетов.

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

Четвертая особенность хранения вещественных значений - не все, казалось бы простые значения, могут быть помещены в вещественные переменные в точности в том же виде в котором они фигурировали в тексте программы. Не смотря на то что и значащих цифр хватает, и число попадает в допустимый диапазон. Например попробуем поместить число 0.3 в переменную типа Real. В процедуре WriteLn числа 21 и 20 указывают формат вывода заставляя печатать значение переменной A используя минимум 21 знак из которых 20 знаков после десятичной запятой. Вы удивитесь, но будет выведено не 0.300000. а 0.29999999999999999000. Очень близко к 0.3 но не 0.3. Т.е. число 0.3 (как и многие другие числа) на самом деле не удается представить точно в двоичной форме. Вы можете использовать значение переменной A в вычислениях, даже не замечая того что она содержит не 0.3, и ошибка вычислений будет минимальна. Если вы попытаетесь вывести пользователю значение переменной A, то пользователь скорее всего увидит именно 0.3 т.к. большинство методов с помощью которых выводится числовая информация для пользователя так или иначе при выводе делает округление до определенного количества цифр. Если вы попытаетесь сравнить это число с другим "по правильному", т.е. так, как описано в третьем следствии, то вы получите верный результат т.к. скорее всего ваш Epsilon будет что-то около 0.001 или 0.000001. Это значительно больше расхождения между числом 0.3 и его представлением в переменной типа Real которое мы наблюдаем. Казалось бы со всех сторон мы прикрыты, но помнить об этой особенности надо.

Намного более подробное объяснение всех этих тонкостей можно прочитать в статье: Неочевидные особенности вещественных чисел написанной Антоном Григорьевым.

Сводная таблица вещественных типов

Тип	Диапазон значений	Формат	Значащих цифр	Прочее
Real	5e-324..1.7e308	знаковый, 8 байт	15..16	общий
Real48	2.9e-39..1.7e38	знаковый, 6 байт	11..12	фундаментальный
Single	1.5e-45..3.4e38	знаковый, 4 байт	7..8	фундаментальный
Double	5e-324..1.7e308	знаковый, 8 байт	15..16	фундаментальный, фактически эквивалентен Real
Extended	3.6e-4951..1.1e4932	знаковый, 10 байт	19..20	фундаментальный
Comp	-2^63+1..2^63-1	знаковый, 8 байт	19..20	фундаментальный
Currency	-922337203685477.5808..922337203685477.5807	знаковый, 8 байт	19..20	фундаментальный, с фиксированной точкой

Примечания по поводу разных типов данных

Real48

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

Extended

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

Примечание:
Честно говоря эту фразу я сдул прямо из борладновского хелпа, слабо понимая что она значит и почему все именно так а не иначе. :-)

Устаревший тип данных. В действительности хранится как 64-ех битное целое число, однако трактуется как вещественное т.к. к нему неприменимы операции которые обычно могут быть выполнены над целыми числами. Например получение следующего или предыдущего значений. Вместо него где только возможно нужно использовать Int64.

Currency

Фиксированная десятичная точка. В действительности хранится как 64-ех разрядное целое число с четырьмя наименее значимыми цифрами неявно считающимися дробной частью. Используется для выражения денежных величин. Финансовые вычисления с точностью до 4-ех знаков после десятичной точки - общепринятая мировая практика позволяющая снизить ошибки при расчетах.

Резюме про вещественные типы данных

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

Арифметические операции

Сложение "+"
Вычитание "-"
Умножение "*"
Деление "/"
Деление нацело "div"
Остаток от деления нацело "mod"

4+5 - сложение двух констант 4 и 5
A*9/C - значение в переменной (или константе) по имени A умножить на девять и результат разделить на значение находящееся в переменной (или константе) по имени C.
Z div 10+1 - разделить значение Z на десять нацело и прибавить к результату 1

Приоритет операций

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

A+B-C/6*25 выполняется в следующей последовательности A+B, C/6, C/6*25, A+B-C/6*25.
(A+(B-C)/6)*25 Тут последовательность была изменена скобками: B-C, (B-C)/6, A+(B-C)/6, (A+(B-C)/6)*25.

Оператор присваивания

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

B:=A/Z; - переменной B присваивается результат деления значения переменной A на значение переменной Z.
D:=(A+(B-C)/6)*25; - переменной D присваивается результат вычисления выражения (A+(B-C)/6)*25.

Примечание:
Была у меня когда-то японская книжка, автор которой исходил из главной идеи что программированию будут учиться полные дауны. Там вся эта математика разжевывалась так что не понять было невозможно. Со схемами и сценками из жизни японцев. Жаль не сохранилась, мне очень помогла. :-)

Совместимость типов данных

Рассмотрим простейший пример программы в котором проявляется проблема совместимости типов данных. Что мы здесь видим? Во первых, вещественной переменной B присваивается целочисленное значение 47 являющееся результатом сложения двух целочисленных констант 15 и 32. Т.е. здесь мы можем наблюдать неявное преобразование типа выражения 15+32 из целочисленного в вещественный, так чтобы вещественное значение 47.0 можно было разместить в вещественной переменной B. Во вторых, мы наблюдаем попытку присвоить целочисленной переменной A вещественный результат вычисления выражения B/3. Если первый оператор присваивания не вызовет возражений со стороны компилятора, то на второй оператор будет выдана ошибка компиляции.

Рассмотрим второй пример программы. Здесь мы наблюдаем попытку присвоения переменной B значения которое выходит за допустимый диапазон значений для типа данных Real. Этот код так-же вызовет ошибку.

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

A+5 - тип результата Integer
A+B - тип результата Real
A+B*C - тип результата Extended
B/A - тут казалось бы достаточно типа Real, но в действительности для Delphi тип результата деления Extended всегда

В случае с присвоением результатов значений надо заметить что вещественные и целочисленные типы данных неявно совместимы внутри самих себя. Попытка присвоить переменной типа Byte значение переменной типа Integer будет синтаксически верной, т.е. не вызовет ошибки компиляции. Ведь может быть в переменной типа Integer лежит значение 5, которое вполне подходит как для Byte так и для Integer. Однако в этом случае компилятор вставляет машинный код который контролирует значение присваиваемое переменной типа Byte. Если это окажется значение не попадающее в диапазон 0..255, (диапазон допустимых значений для Byte) то во время выполнения программы случится ошибка. То-же самое относится и к вещественным типам данных.

Смотрите также материалы по темам: [Типы данных]

Если вы заметили орфографическую ошибку на этой странице, просто выделите ошибку мышью и нажмите Ctrl+Enter.
Функция может не работать в некоторых версиях броузеров.

0 - 4 294 967 295

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

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

Вещественные (дробные) типы

2.9x 10 -39 -1.7x10 38

1.5 x 10 -45 -3.4х 10 38

5.0x10- 324 -1.7x10 308

3.6x10- 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-символом.

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.

Ordinality of expression's value

Does not take Int64 arguments.

Predecessor of expression's value

Successor of expression's value

Ordinal type identifier or variable of ordinal type

Highest value in type

Also operates on short-string types and arrays.

Ordinal type identifier or variable of ordinal type

Lowest value in type

Also operates on short-string types and arrays.

For example, High(Byte) returns 255 because the highest value of type Byte is 255, and Succ(2) returns 3 because 3 is the successor of 2.

Integer Types

An integer type represents a subset of the integral numbers.

Integer types can be platform-dependent and platform-independent.

Platform-Dependent Integer Types

The platform-dependent integer types are transformed to fit the bit size of the current compiler platform. The platform-dependent integer types are NativeInt, NativeUInt, LongInt, and LongWord. Using these types whenever possible, since they result in the best performance for the underlying CPU and operating system, is desirable. The following table illustrates their ranges and storage formats for the Delphi compiler.

Platform-dependent integer types

-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)

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

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

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

In general, arithmetic operations on integers return a value of type Integer, which is equivalent to the 32-bit LongInt. Operations return a value of type Int64 only when performed on one or more Int64 operands. Therefore, the following code produces incorrect results:

To get an Int64 return value in this situation, cast I as Int64:

Note: Some standard routines that take integer arguments truncate Int64 values to 32 bits. However, the High, Low, Succ, Pred, Inc, Dec, IntToStr, and IntToHex routines fully support Int64 arguments. Also, the Round, Trunc, StrToInt64, and StrToInt64Def functions return Int64 values. A few routines cannot take Int64 values at all.

When you increment the last value or decrement the first value of an integer type, the result wraps around the beginning or end of the range. For example, the ShortInt type has the range -128..127; hence, after execution of the code:

the value of I is -128. If compiler range-checking is enabled, however, this code generates a runtime error.

Character Types

A string constant of length 1, such as 'A', can denote a character value. The predefined function Chr returns the character value for any integer in the range of WideChar; for example, Chr(65) returns the letter A.

AnsiChar and WideChar values, like integers, wrap around when decremented or incremented past the beginning or end of their range (unless range-checking is enabled). For example, after execution of the code:

Letter has the value A (ASCII 65).

Boolean Types

The 4 predefined Boolean types are Boolean, ByteBool, WordBool, and LongBool. Boolean is the preferred type. The others exist to provide compatibility with other languages and operating system libraries.

A Boolean variable occupies one byte of memory, a ByteBool variable also occupies one byte, a WordBool variable occupies 2 bytes (one word), and a LongBool variable occupies 4 bytes (2 words).

Boolean values are denoted by the predefined constants True and False. The following relationships hold:

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 identifiers are listed in the type declaration. You can override this by explicitly assigning ordinalities to some or all of the values in the declaration. To assign an ordinality to a value, follow its identifier with = constantExpression, where constantExpression is a constant expression that evaluates to an integer. For example:

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 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.

Читайте также: