Типы переменных в delphi таблица. Типы данных в 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 - ложь
Я всё сделал и у меня получилось вот так:
Сейчас нам нужно создать событие OnClick
на кнопке, я надеюсь, что вы помните, как это делать.
Переменные объявляются между ключевыми словами procedure
и begin
.
Объявление начинается с ключевого слова var
, потом пишется имя
переменной и через двоеточие
её тип
. Заканчивается все как всегда точкой с запятой.
Создадим переменную S типа String в процедуре OnClick : procedure TForm1.Button1Click(Sender: TObject); var S:string; begin end; После этого между ключевыми словами begin end присвоим переменной значение равное "Моя первая переменная". Присвоение пишется следующим образом. Пишем имя переменной, оператор присвоения := и значение . Если мы записываем информацию типа String , то информация заключается в одинарные кавычки.
Общий вид: procedure TForm1.Button1Click(Sender: TObject); var S:string; begin S:="Моя первая переменная"; end; Теперь если скомпилировать программу и нажать на кнопку ничего существенного не произойдет, просто в переменную запишется значение и всё. Попробуем вывести значение из переменной. Делается это также просто как и записывается. Выводить значение мы будем в наш Label .
Синтаксис такой: Label1.Caption:=S; Разберем этот код подробно. Сначала мы написали Label1 , потом пишем точку и в Delphi появляется огромный список со свойствами данного компонента. Можно конечно порыться и отыскать там Caption , но мы будем умнее! Мы, после того как поставили точку, напишем еще букву C и Delphi как бы отсортирует все свойства и найдет все, которые начинаются с буквы C . Первым в списке как раз будет свойство Caption .
Выбираем его из списка и нажимаем на Enter . Заметьте, что мы писали , но после того, как нажали Enter , Delphi сам дописал название свойства. Далее опять же идет оператор присвоения и наша переменная.
Вы наверняка спросите: "Зачем же переменная, если можно было написать Label1.Caption:="Моя первая переменная";?". Ответ простой. Это нужно затем, что мы изучаем переменные:).
Нет, на самом деле так присваивать тоже можно, но представьте такую ситуацию, что вы написали очень большую,
популярную программу и у вас, там в программе, пятидесяти
компонентам присваивается одно и тоже значение и вот перед вами встала задача:
"Поменять это значение на более универсальное и понятное для пользователя".
Что вы будете делать?
- В первом случае у вас всем этим компонентам присваивается одна и та же переменная и чтобы изменить всем этим пятидесяти компонентам значение вам просто нужно поменять значение в переменной.
- Во втором случае вы сидите 20 минут и всё копируете и копируете значение всем пятидесяти компонентам.
И так, продолжаем! В общем виде должно быть так: procedure TForm1.Button1Click(Sender: TObject); var S:string; begin S:="Моя первая переменная"; Label1.Caption:=S; end; Компилируем нашу программу и нажимаем на Button (батон/кнопку). Сразу же компонент Label вместо Label1 будет показывать Моя первая переменная .
На этом хотелось бы закончить, так как я уже устал писать урок:), но я еще не познакомил вас с типом Integer
и как присваивать переменную с таким типом.
Вы думаете, что присваивать ее нужно точно так же как и переменную типа String
, но вы ошибаетесь.
Дело в том, что свойству Caption
вообще у всех компонентов можно присвоить только текстовые значения.
Как мы будем присваивать числовой тип если можно только текстовой? Всё проще некуда. Между типами переменных можно как бы переключаться,
то есть можно из числового типа сделать текстовой и присвоить его компоненту Label
. Этим мы сейчас и займемся.
Для начала нужно начать сначала:). Объявим переменную с именем I и типом Integer , дописав ее к переменной S . Код: procedure TForm1.Button1Click(Sender: TObject); var S:string; I:integer; begin ... Далее присвоим переменной I значение 21 . I:=21; Заметьте, что числовое значение записывается без одинарных кавычек! Теперь присвоим свойству Caption значение переменной I , для этого нужно воспользоваться оператором IntToStr() . Он как бы конвертирует числовой тип в текстовой. В скобках указывается переменная, которую нужно конвертировать.
Общий вид кода: procedure TForm1.Button1Click(Sender: TObject); var S:string; I:integer; begin S:="Моя первая переменная"; Label1.Caption:=S; I:=21; Label1.Caption:=IntToStr(I); end; Скомпилируйте программу и вы увидите, что Label будет отображать значение переменной I , то есть 21 .
Ну вот и всё! Удачи!
Встретимся в следующем уроке!
Данные в компьютере можно рассматривать как ячейки памяти, имеющие свои имена (идентификаторы). Все данные в программе на языке Delphi должны быть описаны до их первого использования. И компилятор следит, чтобы в программе они использовались в соответствии с этим описанием, что позволяет избежать ошибок.
Любая величина в Delphi может быть постоянной или переменной. Её имя (идентификатор) может состоять из комбинации латинских букв, цифр и знака подчёркивания, и начинаться не с цифры. При этом регистр символов значения не имеет.
Место описания данных в программе - вне логических блоков begin / end . В модуле перед ключевым словом implementation есть блок описания:
var
Form1: TForm1;
Именно здесь, начиная со следующей строки, удобно объявлять глобальные переменные и константы. Как видим, одна (Form1) уже есть!
Команда объявления переменных в языке Delphi :
var имя_переменной : тип_переменной ;
Слово var - ключевое. Именем может быть любой идентификатор, если он не был описан ранее и не является одним из ключевых или зарезервированных слов языка Delphi . Если нужно описать несколько переменных одного типа, то их перечисляют, отделяя запятой:
var A, B, C : Integer;
Если несколько описаний следуют друг за другом, то ключевое слово var повторно можно не указывать:
var
A, B : Integer;
C, D : String;
Постоянную величину иначе называют константой . Конечно, в программе можно использовать числа и строки непосредственно: 3.1415 или "Это значение числа пи" , но иногда удобнее присвоить их идентификатору. Описание констант аналогично описанию переменных, но используется ключевое слово const , за именем идентификатора следует тип, затем знак равенства и его значение. Причём тип константы допускается не указывать:
const
pi=
3.1415
;
ZnakPi : String =
"Это значение числа пи"
;
К слову, константа Pi встроенная в Delphi, то есть для того чтобы использовать в Delphi число 3,1415... в расчётах, нужно просто присвоить встроенную константу Pi переменной типа Real или просто использовать непосредственно в выражениях.
Теперь пришло время узнать о типах данных, используемых в Delphi . Прежде всего это строки и числа.
Строкой
называется последовательность символов, заключённая в одиночные кавычки:
"это текстовая строка"
Если текст должен содержать сам символ кавычки, то его надо повторить дважды:
"это "" - символ одиночной кавычки"
Строка может быть и пустой, не содержащей символов. Тогда она состоит из двух идущих друг за другом без пробела кавычек.
Естественно, строка может состоять и только из одних пробелов.
Самый популярный строковый тип - String
. Строка типа String
может содержать переменное количество символов
объёмом до 2 Гбайт. Если нужно ограничить размер строки фиксированным значением, то после ключевого слова String
в квадратных скобках
указывается число, определяющее количество символов в строке: String
. Более полно работа со строками Delphi описывается далее.
Одиночный символ имеет тип Char
и записывается в виде знака в одиночных кавычках: "a"
. Есть
символы, которые на экране отобразить невозможно, например, символ конца строки (равен #13), символ переноса строки (равен #10). Такие символы записываются в виде их числового кода (в кодировке ANSI
), перед которым стоит знак #
. Например, #0
.
Наконец, существуют так называемые нуль-терминированные строки. Отсчёт символов в таких строках начинается с нуля, а
заканчивается символом с кодом 0
(#0
). Такие строки имеют тип PChar
.
Числа
бывают целые
и дробные
.
В следующей таблице перечислены стандартные типы целых чисел и соответствующие им дипазоны допустимых значений.
Дробные числа имеют дробную часть, отделяемую десятичной точкой. Допускается использование символа e
(или E
),
за которым следует число, указывающее, что левую часть нужно умножить на 10 в соответствующей степени: 5e25
- пять умножить на десять в двадцать пятой степени.
Ниже приведены стандартные типы дробных чисел и соответствующие им диапазоны допустимых значений. Для большинства типов указан диапазон
положительных значений, однако допустимым является аналогичный диапазон отрицательных значений, а также число 0
.
Следующим типом данных является логический Boolean , состоящий всего из двух значений: True (Истина) и False (Ложь). При этом True > False .
Теперь, используя компоненты, их свойства и события, вводя собственные переменные, можно конструировать программы, содержащие
вычисления. Осталось узнать, как вычисленное значение вывести на экран.
Про консольные программы я здесь не говорю
! А в нормальных оконных Windows-приложениях это значение нужно поместить в какой-нибудь компонент, имеющий
свойства Text
или Caption
. Это, например, такие компоненты как Label
и Edit
, да и сама Форма имеет свойство
Caption
, куда тоже можно выводить информацию. Однако, в Delphi информацию перед выводом, как правило, необходимо преобразовывать. Так как присвоение возможно только между переменными одного типа, то такая программа (не пытайтесь её исполнять):
var
A, B, C: Integer ;
begin
A:= 5 ;
B:= 10 ;
C:= A+B ;
Label1.Caption:= C ;
end ;
Вызовет ошибку, так как свойство Caption имеет текстовый тип String , а использованные переменные - цифровой тип Integer . Значит, нужно преобразовать значение переменной C в текстовый тип. Для этого есть встроенная функция IntToStr . Строка в нашей "программе", вызывавшая ошибку, должна выглядеть так:
Label1.Caption:= IntToStr(C) ;
Такая программа, кроме показа числа 15 , ни на что не способна. Мы должны научиться вводить в программу другие числа. Используем компоненты Edit . Введённые числа будут содержаться в свойстве Text этих компонентов. Расположим на форме два компонента Edit , один компонент Label и кнопку Button , по нажатию на которую и будем проводить вычисления. В компоненты Edit1 и Edit2 будем вводить числа для суммирования. Чтобы переместиться в редактор кода, щёлкнем дважды по нашей кнопке Button1. Мы попадём прямо в сформированную для нас средой Delphi заготовку обработчика нажатия на кнопку, непосредственно между операторами begin и end . Напишем такой простой код:
procedure
TForm1.Button1Click(Sender: TObject);
var
A, B, C: Integer;//Не забудьте описание переменных
begin
//Начало кода:
A:= Edit1.Text;
B:= Edit2.Text;
C:= A+B;
Label1.Caption:= IntToStr(C);
//Конец кода
end ;
При попытке исполнить этот код Delphi покажет ошибки по аналогичной причине - переменные A и B имеют цифровой тип Integer , а свойство Text - текстовый тип String . Исправить ошибки поможет встроенная функция StrToInt , выполняющая обратное преобразование - текст в целое число. Операторы присвоения переменным A и B должны выглядеть так:
A:= StrToInt(Edit1.Text);
B:= StrToInt(Edit2.Text);
В данном случае переменные A, B, C использовались для наглядности. Можно обойтись одной строчкой:
Label1.Caption:=IntToStr(StrToInt(Edit1.Text)+StrToInt(Edit2.Text));
Аналогично, имеются функции и для преобразования в строку и обратно действительных чисел c плавающей (Float
ing англ.) запятой, имеющих тип
Real
. Для преобразования в строку - FloatToStr
, обратно - StrToFloat
.
Часто результаты вычислений, имеющие тип Delphi Real
, имеют после запятой длинный "хвост" цифр. При выводе такой переменной в текстовом виде необходимо ограничить количество цифр после запятой. Как это можно сделать, описывается также в Уроке Delphi
Порядковые типы
Из простых типов данных порядковые - самые простые.
В этих типах информация представляется в виде отдельных элементов. Связь
между отдельными элементами и их представлением в памяти определяет естественные
отношения порядка между этими элементами. Отсюда и название порядковые.
В Object Pascal определены три группы порядковых
типов и два типа, определяемых пользователем. Группы - это целые, символьные
и булевы типы. Порядковые типы, задаваемые пользователем, - это перечисления
и поддиапазоны.
Все значения любого порядкового типа образуют упорядоченную
последовательность, и значение переменной порядкового типа определяется
его местом в этой последовательности. За исключением переменных целых типов,
значения которых могут быть как положительными, так и отрицательными, первый
элемент любого порядкового типа имеет номер 0, второй элемент - номер 1
и т.д. Порядковый номер целого значения равен самому значению. Отношение
порядка определяет общие для данных всех порядковых типов операции. Некоторые
стандартные функции такого вида встроены в Object Pascal. Они представлены
в табл. 1.1.
Для всех порядковых типов в Object Pascal существует операция задания типа для преобразования целых значений в значения соответствующих порядковых типов. Если Т - имя порядкового типа, а Х - целое выражение, то Т (X) воз-вращает значение Т с порядковым номером X.
Совет: Программисты, работающие на С и C++, для приращения или уменьшения значений переменных привыкли заметку использовать операторы "++" и "--", возвращающие следующее и предыдущее значения. Программисты Delphi всегда разбивают эти операции на более простые составляющие с помощью функций Pred, Succ. Dec и Inc.
- Таблица 1.1.
Операции над порядковыми типами
| Операция | Описание |
| Low (T) | Минимальное значение порядкового типа Т |
| High(T) | Максимальное значение порядкового типа Т |
| Ord(X) | Порядковый номер значения выражения порядкового типа. Для целого выражения - просто его значение. Для остальных порядковых типов Ord возвращает физическое представление результата выражения, трактуемое как целое число. Возвращаемое значение всегда принадлежит одному из целых типов |
| Pred(X) | Предыдущее по порядку значение. Для целых выражений эквивалентно Х-1 |
| Succ(X) | Следующее по порядку значение. Для целых выражений эквивалентно Х+1 |
| Dec(V) | Уменьшает значение переменной на 1. Эквивалентно V:= Pred(V) |
| Inc(V) | Увеличивает значение переменной на 1. Эквивалентно V:= Succ(V) |
Целые типы
В переменных целых типов информация представляется в виде целых чисел, т.е. чисел не имеющих дробной части. Определенные в Object Pascal целые типы подразделяются на физические (фундаментальные) и логические (общие). При программировании удобнее использовать логические целые типы, которые задают объем переменных в зависимости от типа микропроцессора и операционной среды таким образом, чтобы достигалась максимальная эффективность. Физические целые типы следует применять лишь в тех случаях, когда в первую очередь важны именно диапазон значений и физический объем переменной. В Object Pascal определены следующие целые типы.
- Integer
Shortint
Smallint
Longint
Byte
Word
Cardinal
- Таблица 1.2.
Физические целые типы
| Тип | Диапазон значении | Физический формат |
| Shortint | -128-127 | 8 бит, со знаком |
| Smallint | -32 768-32 767 | 16 бит, со знаком |
| Longint | -2 147 483 648-2 147 483 647 | 32 бит, со знаком |
| Byte | 0-255 | 8 бит, без знака |
| Word | 0-65 535 | 16 бит, без знака |
Диапазоны значений логических целых типов (Integer и Cardinal) определяются совершенно иным образом. Как видно из табл. 1.3, они никак не связаны с диапазонами соответствующих физических типов. Обратите внимание, что в Delphi по умолчанию задано 32-разрядное представление.
Таблица 1.3. Логические целые типы
| Тип | Диапазон значений | Физический формат |
| Integer | -32 768-32 767 | 16 бит, со знаком (SmalIInt) |
| Integer | -2 147 483 648-2 147 483 647 | 32 бит, со знаком (Longint) |
| Cardinal | 0-65 535 | 16 бит, без знака (Word) |
| Cardinal | 0-2 147483647 | 32 бит, без знака (Longint) |
Совет:
В С и C++ для целых значений определены типы int,
short int (или просто short) и long int (или просто long). Тип int
из C/C++ соответствует типу Integer из Delphi, a long из C/C++ -
Longint из Delphi. Однако Shortint из C/C++ соответствует в Delphi не Shortint,
a Smalltlnt. Эквивалент Shortint из Delphi в C/C++- это signed char.
Тип unsigned char в C/C++ соответствует типу Byte из Delphi. В C/C++
существует еще тип unsigned long, аналога которому в Delphi нет.
Над целыми данными выполняются все операции, определенные
для порядковых типов, но с ними все же удобнее работать как с числами,
а не с "нечисленными порядковыми типами". Как и "живые" числа, данные целых
типов можно складывать (+), вычитать (-) и умножать (*). Однако некоторые
операции и функции, применяемые к данным целых типов, имеют несколько иной
смысл.
Символьные типы
Смысл символьных данных очевиден, когда они выводятся
на экран или принтер. Тем не менее, определение символьного типа может
зависеть от того, что подразумевать под словом символ. Обычно символьные
типы данных задают схему взаимодействия между участками памяти разного
объема и некоторым стандартным методом кодирования/декодирования для обмена
символьной информацией. В классическом языке Pascal не задано никакой схемы,
и в конкретных реализациях применялось то, что на том же компьютере мог
использовать каждый.
В реализациях языка Pascal для первых микропроцессоров
была применена 7-битовая схема, названная ASCII (American Standard Code
for Information Interchange - Американский стандартный код для обмена информацией).
Эта схема и поныне широко распространена, но информация хранится, как правило,
в 8-битовых участках памяти. Дополнительный бит удваивает число возможных
представлений символов, но реализации расширенного набора символов ASCII
часто бывают далеки от стандарта. В данной версии Delphi определен набор
8-битовых символов, известный как расширенный (extended) ANSI (American
National Standards Institute - Американский национальный институт стандартов).
Как бы то ни было, символьную схему приходится воспринимать так, как ее
воспринимает операционная система. Для оконных операционных систем фирмы
Microsoft это схема ANSI, включающая ограниченное число предназначенных
для вывода международных знаков. В стремлении же применить более обширный
набор международных знаков весь компьютерный мир переходит к 16-битовой
схеме, именуемой UNICODE, в которой первые 256 знаков совпадают с символами,
определенными в схеме ANSI.
Для совместимости со всеми этими представлениями
в Object Pascal определены два физических символьных типа и один логический.
Физические типы перечислены ниже.
Логический символьный тип именуется char. В классическом языке Pascal char- единственный символьный тип. В Delphi char всегда соответствует физическому типу данных AnsiChar. У американских программистов ассоциация символа с однобайтовой ячейкой памяти укоренилась за долгие годы настолько, что им зачастую просто не приходит в голову, что можно использовать другие схемы кодирования. Однако дискуссии по интернационализации программ в Internet и World Wide Web могут существенно изменить их отношение к проблеме объема символьных данных. Применяя логический тип char, следует делать реализации для других микропроцессоров и операционных систем, в которых char может определяться как WideChar. При написании программ, которые могут обрабатывать строки любого размера, для указания этого размера рекомендуется применять функцию SizeOf, не задавая ее жестко постоянной. Функция Ord (С), где С - любая переменная символьного типа, возвращает целое значение, которым символ С представлен в памяти. Совет: Процессор не различает типы char, определенные в C/C++ и Delphi. Однако функционально каждый из этих языков трактует данный тип совершенно по-разному. В C/C++ это целый тип, переменной которого можно присваивать целые значения. Переменной int можно присвоить символьное значение, а переменной char - целое. В Delphi символьные типы жестко отделены от численных. Для присвоения численному значению символьного здесь необходимо воспользоваться функцией Ord. В языке Basic один символ представляется так же, как и строка символов. Функция Chr из Delphi эквивалентна функции CHR$ из Basic. Функция Ord из Delphi, возвращающая код ANSI символьной переменной, подобна функции A3 С из Basic, аргумент которой представляет односимвольную строку.
Булевы типы
На ранней стадии обучения программисты осваивают
понятие бита, два состояния которого можно использовать для записи информации
о чем-либо, представляющем собой одно из двух. Бит может обозначать 0 или
1, ДА или НЕТ, ВКЛЮЧЕНО или ВЫКЛЮЧЕНО, ВЕРХ или НИЗ, СТОЯТЬ или ИДТИ. В
Object Pascal информация о чем-либо, что можно представить как ИСТИНА (True)
или ЛОЖЬ (False), хранится в переменных булевых типов. Всего таких типов
че-тыре, и они представлены в табл. 1.4.
- Таблица 1.4.
Размеры переменных булевых типов
| Тип | Размер |
| Boolean | 1 байт |
| ByteBool | 1 байт |
| WordBool | 2 байт (объем Word) |
| LongBool | 4 байт (объем Longint) |
Переменным типа Boolean можно присваивать только значения True (истина) и False (ложь). Переменные ByteBool, WordBool и LongBool могут принимать и другие порядковые значения, интерпретируемые обычно как False в случае нуля и True - при любом ненулевом значении.
Совет:
Булевы типы в Delphi можно сравнить с типом LOGICAL языка
FORTRAN. В Basic, С и C++ булевы типы как таковые отсутствуют. Булевы выражения
в этих языках применяются точно так же, как во всех остальных, однако результаты
этих выражений интерпретируются не как значения отдельного типа, а как
целые числа. Как в Basic, так и в C/C++ булевы выражения дают численные
результаты, интерпретируемые как False в случае 0 и True - в случае любого
ненулевого значения. Это совместимо с порядковыми значениями булевых выражений
в Delphi. В C/C++ простые сравнения дают результат 1 (True) или 0 (False).
Это эквивалентно булевым значениям Delphi. Только результат сравнения в
Delphi выводится как булевый, а не целый. В большинстве случаев типу Boolean
из Delphi соответствует тип char в C/C++. В Basic зарезервированы слова
TRUE (эквивалентно константе -1) и FALSE (эквивалентно константе 0). В
Basic TRUE меньше FALSE, в Delphi, наоборот, False меньше True.
Перечислимые типы
Type enum type = (first value, value2, value3, last
value);
Обычно данные перечислимых типов содержат дискретные
значения, представляемые не числами, а именами. Тип Boolean- простейший
перечислимый тип в Object Pascal. Булевы переменные могут принимать два
значения, выражаемые именами True и False, а сам тип определен в Object
Pascal так, как будто он объявлен следующим образом:
Type Boolean = (False, True);
С помощью типа Boolean в Object Pascal выполняются
сравнения, большинство же перечислимых типов - это просто списки уникальных
имен или идентификаторов, зарезервированных с конкретной целью. Например,
можно создать тип MyColor (мой цвет) со значениями myRed, myGreen и myBlue
(мой красный, мой зеленый, мой синий). Это делается совсем просто:
Type MyColor = (myRed, myGreen, myBlue);
В этой строке объявлены четыре новых идентификатора:
MyColor, myRed, myGreen и myBlue. идентификатором MyColor обозначен порядковый
тип, следовательно, в синтаксисе Object Pascal можно применять этот идентификатор
везде, где разрешены перечислимые типы. Остальные три идентификатора- это
значения типа MyColor. Подобно символьным и булевым типам перечислимые
не являются числами, и использовать их наподобие чисел не имеет смысла.
Однако перечислимые типы относятся к порядковым, так что значения любого
такого типа упорядочены. Идентификаторам в списке присваиваются в качестве
порядковых номеров последовательные числа. Первому имени присваивается
порядковый номер 0, второму - 1 и т.д.
Совет:
В С и C++ есть тип enema, аналогичный перечислимому типу
Delphi. Но в этих языках можно произвольно присваивать идентификаторам
постоянные значения. В Delphi же соответствие имен и их значений фиксиро-вано:
первому имени присваивается значение 0, каждому последующему - на единицу
больше. В С тип enum применяется лишь как средство быстрого определения
набора целых постоянных. В C++ объявленные в перечислимом типе идентификаторы
можно присваивать только переменным того же типа.
Поддиапазонные типы
Переменные поддиапазонного типа содержат информацию,
соответствующую некоторому pаданному диапазону значений исходного типа,
представляющего любой порядковый тип, кроме поддиапазонного. Синтаксис
определения поддиапазонного типа имеет следующий вид:
Type subrange type = low value...high value;
Поддиапазонные переменные сохраняют все особенности
исходного типа. Единственное отличие состоит в том, что переменной поддиапазонного
типа можно присваивать только значения, входящие в заданный поддиапазон.
Контроль за соблюдением этого условия задается командой проверки диапазона
(range checking).
Необходимость явно определять поддиапазонный тип
возникает нечасто, но все программисты неявно применяют эту конструкцию
при определении массивов. Именно в форме поддиапазонной конструкции задается
схема нумерации элементов массива.
Действительные типы
В переменных действительных типов содержатся числа,
состоящие из целой и дробной частей. В Object Pascal определено шесть действительных
типов. Все типы могут представлять число 0, однако они различаются пороговым
(минимальным положительным) и максимальным значениями, которые могут представлять,
а также точностью (количеством значащих цифр) и объемом. Действительные
типы описываются в табл. 1.5.
- Таблица 1.5.
Действительные типы.
| Тип | Порог | Максимальное значение | Количество значащих цифр | Объем (байт) |
| Real | 2.9E-39 | 1.7Е38 | 11-12 | 6 |
| Single | 1.5E-45 | 3.4Е38 | 7-8 | 4 |
| Double | 5.0E-324 | 1.7Е308 | 15-16 | 8 |
| Extended | 3.4E-4932 | 1.IE4932 | 19-20 | 10 |
| Comp | 1.0 | 9.2Е18 | 19-20 | 8 |
| Currency | 0.0001 | 9.2Е14 | 19-20 | 8 |
Целые типы представляют целые числа, т.е. числа,
дробная часть которых равна нулю. Разница между двумя неодинаковыми целыми
числами не может быть меньше единицы. Именно благодаря этому целые числа
применяются для обозначения дискретных величин, независимо от того, имеют
ли реальные объекты какое-либо отношение к числам. Действительные типы
предназначены для представления чисел, которые могут иметь дробную часть,
поэтому они полезны для представления величин, которые могут быть довольно
близкими, почти непрерывными.
Заметьте, именно почти. Несмотря на название действительные,
переменные этих типов отличаются от математических действительных чисел.
В Object Pascal действительный тип - это подмножество математических действительных
чисел, которые можно представить в формате с плавающей запятой и фиксированным
числом цифр. Для невнимательных программистов ситуация усугубляется тем,
что в стандартных форматах IEEE (Institute of Electrical and Electronic
Engi-neers - Институт инженеров- электриков и электронщиков), применяемых
в программах Delphi и вообще в большинстве программ для Windows, возможно
точное представление только чисел с фиксированным числом бит в дробной
части. Удивительно, но такое простое число, как 0,1, записывается в расширенном
формате IEEE с некоторой погрешностью, пусть очень небольшой. Из-за этого
представление с плавающей запятой оказывается несколько неудобным для программ,
в которых сохраняется и выводится фиксированное число десятичных разрядов
численных значений. Это относится и к программам, работающим с ""живыми"
деньгами.
Для частичного решения этой проблемы в Object Pascal
определены два формата с фиксированной запятой. Тип Comp (computational
- вычислительный) содержит только целые числа в диапазоне от -2 63 +1
до 2 63 -1, что примерно соответствует диапазону от -9,2х10 18
до 9,2х10 18 . При программировании операций с американской валютой
разработчикам обычно приходится искать естественный способ записи денежных
сумм, в котором целая часть числа определяет количество долларов, дробная
- центов. Если такие значения записывать в переменные типа Comp, придется
представлять их в виде целого числа центов. В этом случае следует умножать
значение на 100 для обращения центов в доллары, а затем делить на 100,
чтобы снова получить центы.
Этих забот можно избежать, если воспользоваться
типом Currency. В этом случае задачу выбора масштаба возьмет на себя компилятор.
Физически значения Currency записываются в память того же объема, что и
Comp, как целые числа, однако компилятор не забывает вовремя разделить
значение на 10 000 (не на 100!) для его приведения в соответствие с денежным
знаком и умножить на 10 000 перед записью в память. Это обеспечивает абсолютную
точность в четыре десятичных знака после запятой.
В Delphi есть модуль System, содержащий ряд процедур обработки данных
действительных типов. Наиболее распространенные из них перечислены в табл.
1.6. Много полезных процедур содержится также в модулях SysUtils и Math.
- Таблица 1.6.
Функции действительных типов
| Функция | Возвращаемое значение |
| Abs (x) | Абсолютная величина х |
| АгсТаn(х) | Арктангенс х |
| Cos (х) | Косинус х (х выражается в радианах, а не в градусах) |
| Ехр (х) | Экспоненциальная функция от х |
| Frac(x) | Дробная часть х |
| Int (х) | Целая часть х. Несмотря на название, возвращает действительное значение (с плавающей запятой), т.е. просто устанавливает нуль в дробной части |
| Ln (х) | Натуральный логарифм от х |
| Pi | Число Пи (3.1416...) |
| Round (х) | Ближайшее к х целое значение. Возвращает значение целого типа. Условие "ближайшее к х" не работает, если верхнее и нижнее значения оказываются равноудаленными (например, ес-ли дробная часть точно равна 0,5). В этих случаях Delphi перекладывает решение на опера-ционную систему. Обычно процессоры Intel решают эту задачу в соответствии с рекоменда-цией IEEE округлять в сторону ближайшего четного целого числа. Иногда такой подход на-зывают "банкирским округлением" |
| Sin(x) | Синус х |
| Sqr(x) | Квадрат х, т.е. X*X |
| Sqrt (х) | Квадратный корень от х |
| Тrunc (х) | Целая часть х. В отличие от Int, возвращающей действительное значение, Trunc возвращает целое |
В предыдущих уроках мы между делом знакомились с типами данных. Всё это время речь шла о простых типах. Сегодня мы обобщим пройденное ранее, а также познакомимся с новым материалом, который необходимо знать в рамках темы "Простые типы данных". Осмысленно подходить к выбору типов данных для используемых в программах переменных необходимо по разным причинам. Во-первых, имея под рукой многообразие доступных типов и умело ими распоряжаясь, можно сократить объём памяти, требуемый программе для работы. Экономию в 1-2 байта никто не заметит, но если речь идёт о больших объёмах данных, эти байты могут вылиться во вполне реальные мегабайты. Во-вторых, разумный выбор типов данных позволяет избежать некоторых ошибок, причём как со стороны программиста (на этапе создания программы), так со стороны пользователя (во время использования программы).
Простые типы данных - общее представление
Простые типы данных названы простыми, потому что они не содержат внутри себя никаких других типов. Кроме того, простые типы данных обеспечивают хранение в памяти только одного значения. К простым типам данных относят следующие:
- целочисленные;
- вещественные;
- логические;
- строковые (символьные).
Следует отметить, что все эти типы за исключением вещественного, упорядочены. Что это значит? А это значит, что в рамках данного типа значения расположены не в произвольном порядке, а в порядке возрастания. Зная об этом, в некоторых случаях можно исключить в своей программе лишний код. Поясню на примере, как именно упорядочены значения в этих типах данных:
Целочисленный тип - содержит числовые значения, целые числа. Числа упорядочены по возрастанию: ..., -2, -1, 0, 1, 2, 3, ...
Логический тип - содержит всего 2 значения - True, False, которые тоже упорядочены: False, True (следует из соответствия False - 0, True - 1).
Символьный тип - символы кодовой таблицы. Поскольку каждому символу соответствует свой код, то символы расположены в порядке увеличения кода. К примеру, буквы латинского алфавита A, B, C, D, ... идут в кодовой таблице именно так, т.к. чем дальше от начала алфавита, тем больший код имеет буква. То же самое касается и арабских чисел в кодовой таблице - они идут по порядку: 0, 1, 2, ..., 8, 9. Это позволяет делать такие сравнения, как, например "A" < "Z"
(это истинно).
Из того, что перечисленных типы данных упорядочены, следует, что все значения образуют конечную последовательность. Это соответствует нашим представлениям о типах данных - все они имеют свои ограничения. К примеру, нет числового типа данных, который позволил бы хранить сколь угодно большое число. "Большие" типы есть, но "число" "бесконечность" они хранить не могут.
Функции и процедуры для порядковых типов данных
Существует несколько полезных функций и процедур, без использования которых, порой, сложно оперировать порядковыми типами данных:
Pred() - функция возвращает предыдущее значение для выражения, указанного в качестве единственного аргумента.
Примеры: Pred(5) = 4, Pred("E") = "D", Pred(True) = False.
Succ() - функция, обратная для Pred() - возвращает следующее значение.
Примеры: Succ(5) = 6, Succ("E") = "F", Succ(False) = True.
Ord() - возвращает порядковый номер значения в списке значений типа данных. С этой функцией мы уже встречались при работе со строками - с её помощью мы узнавали код символа.
Примеры: Ord("A") = 65, Ord(True) = 1.
Low() - возвращает минимальное значение указанного типа данных.
Примеры: Low(Byte) = 0, Low(Boolean) = False, Low(Char) = #0 (символ с кодом 0).
High() - возвращает максимальное значение указанного типа данных.
Примеры: High(Byte) = 255, High(Boolean) = True, High(Char) = #255 (в русской локали это символ "я").
Ну и ещё две процедуры, с которыми мы уже знакомы:
Dec() - уменьшает значение на единицу.
Inc() - увеличивает значение на единицу.
Не забывайте о втором необязательном параметре этих процедур.
Пользовательские типы данных
На основе порядковых типов данных программист может создать свои собственные типы - перечислимые и интервальные. Они будут рассмотрены ниже.
Целочисленные типы
Как следует из названия, целочисленные типы позволяют хранить целые числа. Среди них есть типы, которые хранят числа со знаком (т.е. положительные или отрицательные), а есть и такие, которые хранят только положительные. Чем большее количество значений может содержать тип, тем больше памяти он занимает. Рассмотрим целочисленные типы данных.
Сначала рассмотрим беззнаковые типы, т.е. те, которые позволяют хранить только положительные числа и ноль:
Byte - значения 0..255 - занимает в памяти 1 байт.
Word - значения 0..65535 - 2 байта.
LongWord - значения 0..4294967295 - 4 байта.
Теперь типы со знаком (отрицательные числа записываются со знаком минус "-" впереди, неотрицательные могут записываться как со знаком "+", так и без него):
ShortInt - значения -128..127 - 1 байт.
SmallInt - значения -32768..32767 - 2 байта.
LongInt - значения -2147483648..2147483647 - 4 байта.
Int64 - значения -2 ^53 ..2 ^53 -1 - 8 байт.
Существуют также 2 общих типа, которые находят своё отражение в вышеперечисленных. Рекомендуется использовать именно эти типы, т.к. компилятор "заточен" под них и создаёт более быстрый и эффективный код:
Integer - значения -2147483648..2147483647 - 4 байта.
Cardinal - значения 0..4294967295 - 4 байта.
Следует отметить, что целые числа могут быть представлены не только в десятичной, но и в шестнадцатеричной системе счисления, т.е. в виде $xxxxxxxx, где x - один из символов 0, 1, ..., 8, 9, A, B, ..., E, F. К примеру, все цвета (точнее, их коды) представляются именно в виде шестнадцатеричных чисел.
Логические типы
С логическими выражениями и с логическим типом данных мы уже знакомы - это тип Boolean , принимающий значения True и False . Помимо Boolean существуют следующие логические типы: ByteBool , WordBool и LongBool . Однако последние введены лишь для обспечения совместимости с другими языками и системами программирования. Использовать рекомендуется только тип Boolean. Логическое значение в памяти занимает 1 байт. На самом деле, конечно, достаточно и одного бита, но оперировать ячейками меньше байта, мы, к сожалению, не можем.
Символьные типы
Символьные типы обеспечивают хранение отдельных символов. Основной тип данных - Char , который содержит символы с кодами 0..255 . Существуют ещё типы AnsiChar и WideChar . Тип AnsiChar эквивалентен типу Char , т.е. по сути это один и тот же тип. Занимает в памяти 1 байт. Для кодирования символов используется код ANSI (American National Standards Institute ). Тип WideChar кодируется международным кодом Unicode и занимает в памяти 2 байта. Таблица Unicode включает символы практически всех языков мира.
Вещественные типы
Из названия следует, что эти типы используются для хранения вещественных, т.е. действительных чисел. Отличаются они границами допустимых значений и точностью, т.е. числом цифр после запятой. Вот эти типы:
Real (он же Double ) - значения от 5.0x10 ^-324 до 1.7x10 ^308 , точность - 15-16 цифр, занимает в памяти 8 байт.
Real48 - значения от 2.9x10 ^-39 до 1.7x10 ^38 , точность - 11-12 цифр, 6 байт памяти.
Single - значения от 1.7x10 ^-45 до 3.4x10 ^38 , точность - 7-8 цифр, 4 байта.
Extended - от 3.6x10 ^-4951 до 1.1x10 ^4932 , точность - 19-20 цифр, 10 байт памяти.
Comp - от -2x10 ^63 +1 до 2x10 ^63 -1 , точность - 19-20 цифр, 8 байт.
Currency - от -922337203685477.5808 до 922337203685477.5807 , точность - 19-20 цифр, в памяти занимает 8 байт.
Как и в случае с целыми числами, перед вещественными числами может стоять знак "+" или "-".
Существует 2 формы записи вещественных чисел - с фиксированной точкой и с плавающей .
Запись с фиксированной точкой представляет собой обычную запись, в которой целая и дробная части отделены друг от друга точкой/запятой.
Запись с плавающей точкой подразумевает запись порядка числа, который отделяется от самого числа буквой "E" (запись "e" тоже допустима). Например, запись 1.5e2 означает число 1.5 с порядком +2, т.е. это 1.5x10 ^2 = 150.
Типы Comp и Currency были введены специально для произведения точных денежных расчётов. При этом, тип Comp , как видно из значений границ диапазона, хранит целые числа, поэтому при задании чисел с дробной частью они автоматически преобразуются в ближайшее целое число.
Перечислимые типы данных
От рассмотрения готовых типов данных перейдём к типам, которые могут быть созданы самим программистом. Один из вариантов, как было отмечено выше, - это перечислимый тип.
Смысл перечислимого типа в том, что мы явным образом указываем (перечисляем) все возможные значения. Преимущества в том, что кроме заданных значений переменные этого типа не смогут принимать больше никаких значений. Кроме того, значения можно задавать вполне осмысленные - например слова. Это упростит понимание кода и написание программы.
Значения типа данных перечисляются через запятую, а весь этот набор заключается в круглые скобки. Описание типа должно производиться в специальном разделе раздела описаний - разделе описания типов. Этот раздел предваряется ключевым словом type . Т.е. запись идёт приблизительно так же, как и описание переменных или констант, только вместо var и const пишется type . Сам тип описывается следующим образом: название типа, далее знак равенства и далее само значение. В случае с перечислимым типом это будет набор возможных значений.
Примечание: практически все типы данных в Object Pascal принято называть с буквы "T" (сокращённо от "Type"). Это не закон языка - просто одно из правил хорошего тона. Зная, что "T***" - это тип, вы никогда не ошибётесь, в противном же случае название можно спутать, например, с названием переменной.
Допустим, мы хотии задать тип данных, определяющий один из месяцев года. Мы можем описать его так:
type TMonth = (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec ) ; var M: TMonth; {...} M:=Jun;Обратите внимание, что после описания перечислимого типа в программе не может быть переменных, название которых совпадает с названием значений объявленного типа. В нашем примере не может быть переменных "Jan", "Feb" и т.д. При попытке присвоения переменной перечислимого типа значение, не указанное в списке, компилятор выдаст ошибку, поэтому ошибиться не представляется возможным.
Раздел type существует как в модуле всей формы (в этом разделе изначально описана сама форма: TForm1 = class(TForm) ... ), так и в любой подпрограмме. Область действия типа, соответственно, определяется местом в программе, в котором он описан.
Интервальные типы данных
Интервальные типы данных (также их называют ограниченными) получаются из имеющихся типов путём ограничения диапазона значений. Интервал задаётся двумя константами - начальной и конечной границей. При каждом присвоении значения переменной выполняется проверка соответствия нового значения указанному диапазону. Если значение не попадает в диапазон, выдаётся сообщение об ошибке. Во время выполнения программы задание недопустимого значения к ошибке не приводит, зато значение переменной может стать неверным.
Ограниченный тип данных можно создать только на основе простого упорядоченного типа. Значение второй константы (т.е. правой границы) должно быть больше значения первой (левой границы).
Ограниченные типы данных также описывают в разделе type
. Формат записи похожий, только между константами-границами ставятся две точки.
Например, мы хотим в программе работать с датами. Можно создать ограниченные типы данных для значений дня, месяца и года (диапазон для значения года следует задать в зависимости от контекста задачи):
type TDay = 1 ..31 ; TMonth = 1 ..12 ; TYear = 1900 ..2100 ;Помните, что использование ограниченного типа данных не уменьшит объём занимаемой памяти. Это следует из того, что задание интервала - это всего лишь условное задание возможных значений из общего набора значений данного типа.
Заключение
Сегодня мы рассмотрели простые типы данных - целочисленные, вещественные, символьные и логические, а также научились создавать перечислимые и интервальные типы данных в своих программах. Как было отмечено в начале, все эти типы позволяют хранить только одно значение и не содержат внутри себя других типов. В дальнейшем мы перейдём к рассмотрению структурных типов данных, где дело обстоит иначе.
a
- латинская) - только адрес статьи (URL);
{{статья:122}}
- полноценная HTML-ссылка на статью (текст ссылки - название статьи).
К встроенным типам данных в языке Delphi относятся типы целые, действительные, символы, строки, указатели, булевы.
Порядковые типы. Порядковыми (ordinal) типами называются те, в которых значения упорядочены, и для каждого из них можно указать предшествующее и последующее значения.
Структурные типы. К структурным типам относятся множества, массивы, записи, файлы, классы, интерфейсы.
Целые типы данных. В переменных целых типов информация представляется в виде целых чисел, т.е. чисел не имеющих дробной части.
Таблица 1 Операции над порядковыми типами
|
Операция |
Описание |
|
Минимальное значение порядкового типа Т |
|
|
Максимальное значение порядкового типа Т |
|
|
Порядковый номер значения выражения порядкового типа. Для целого выражения - просто его значение. Для остальных порядковых типов Ord возвращает физическое представление результата выражения, трактуемое как целое число. Возвращаемое значение всегда принадлежит одному из целых типов |
|
|
Предыдущее по порядку значение. Для целых выражений эквивалентно Х-1 |
|
|
Следующее по порядку значение. Для целых выражений эквивалентно Х+1 |
|
|
Уменьшает значение переменной на 1. Эквивалентно V:= Pred(V) |
|
|
Увеличивает значение переменной на 1. Эквивалентно V:= Succ(V) |
Таблица 2
|
Диапазон значений |
||
|
2147483648 -- 2147483647 |
||
|
8 битов, беззнаковый |
||
|
16 битов, беззнаковый |
||
|
32 бита, беззнаковый |
Также существует такой тип, как Integer, который эквивалентен типу LongInt. Его диапазон от -2147483648 до 21474836478. Занимает 4 байта в пямяти. Основными являются Integer и Cardinal, так что в большинстве случаев желательно использовать эти типы.
Над целыми данными выполняются все операции, определенные для порядковых типов. Операции над целыми типами:
Таблица 3
Действительные типы данных. В переменных действительных типов содержатся числа, состоящие из целой и дробной частей.
Таблица 4
Основным, обеспечивающим максимальную производительность, является тип Real, который в настоящий момент эквивалентен типу Double.
Таблица 5 Функции действительных типов
|
Возвращаемое значение |
|
|
Абсолютная величина х |
|
|
Арктангенс х |
|
|
Косинус х (х выражается в радианах, а не в градусах) |
|
|
Экспоненциальная функция от х |
|
|
Дробная часть х |
|
|
Целая часть х. Несмотря на название, возвращает действительное значение (с плавающей запятой), т.е. просто устанавливает нуль в дробной части |
|
|
Натуральный логарифм от х |
|
|
Число Пи (3.1416...) |
|
|
Ближайшее к х целое значение. Возвращает значение целого типа. Условие "ближайшее к х" не работает, если верхнее и нижнее значения оказываются равноудаленными (например, если дробная часть точно равна 0,5). В этих случаях Delphi перекладывает решение на операционную систему. Обычно процессоры Intel решают эту задачу в соответствии с рекомендацией IEEE округлять в сторону ближайшего четного целого числа. Иногда такой подход называют "банкирским округлением" |
|
|
Квадрат х, т.е. X*X |
|
|
Квадратный корень от х |
|
|
Целая часть х. В отличие от Int, возвращающей |
Символьные типы данных. Символьные типы предназначены для хранения одного символа.
Таблица 6
Булевы типы данных. Переменные булевых типов данных представляют логические значения, например, true (истина) и false (ложь).
Таблица 7 Размеры переменных булевых типов
|
2 байт (объем Word) |
|
|
4 байт (объем Longint) |
Массив -- это структура данных, представляющая собой набор переменных одинакового типа, имеющих общее имя. Массивы удобно использовать для хранения однородной по своей природе информации, например, таблиц и списков.
Объявление массива
Массив, как и любая переменная программы, перед использованием должен быть объявлен в разделе объявления переменных. В общем виде инструкция объявления массива выгладит следующим образом:
Имя: [нижний_индекс..верхний_индекс] of тип
где: имя -- имя массива;
array -- зарезервированное слово языка Delphi, обозначающее, что объявляемое имя является именем массива;
нижний_индекс и верхний_индекс -- целые константы, определяющие диапазон изменения индекса элементов массива и, неявно, количество элементов (размер) массива;
тип -- тип элементов массива.
