Extended тип данных в delphi. Численные переменные и типы данных. Целочисленный тип данных в Delphi представлен

Данные в компьютере можно рассматривать как ячейки памяти, имеющие свои имена (идентификаторы). Все данные в программе на языке 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

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

Только обязательное назначение типа переменной обеспечит эффективную работу приложения с минимальной нагрузкой на компьютерную систему.

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

Целочисленный тип данных в Delphi представлен:

• Shortint - занимает в памяти 8 битов и имеет числовой диапазон от -127 до 128.
• Smallint - числовой интервал находится в пределах -32 768 - 32 767 (16 битов).
• Longint – диапазон чисел от -2 147 483 648 до 2 147 483 647 (32 бита).
• Int64- наибольший интервал от – 263 до 263-1 (64 бита).
• Byte- интервал значений от 0 до 255 (8 бит).
• Word- числовой диапазон от 0 до 65535 (16 бит).
• Longword –интервал составляет 0 - 4 294 967 295 (32 бита).

Следует заметить, что последние 3 типа называются беззнаковыми так, как имеют в своем числовом интервале только положительные числа(нет отрицательных значений). К тому же можно использовать и тип “Integer”, который соответствует “Longint”. К тому же следует знать, что значения в типах имеют строгий порядок. Такое положение позволяет использовать по отношению к значениям различные процедуры и функции. Не относится к вещественному типу данных в Delphi(не упорядочен).

Числа с плавающей точкой (дробные) представлены в delphi вещественным типом. Вещественный тип данных делится на 6 типов, которые отличаются числовым диапазоном, количеством значащих цифр и занимаемой памятью.

• Single- число может находиться в интервале 1.5 x 1045-3.4х 1038.Объем занимаемой памяти 4 байта.
• Real48 - числовой диапазон 2.9x-39-1.7x1038 (6 байт).
• Double - интервал составляет 5.0x10-324 -1.7x10308 (8 байт).
• Extended - 3.6x10-4951 -1.1 х104932 (10 байт).
• Comp - диапазон чисел 263+1 – 263-1, занимаемая память 8 байт.

Currency – этот вещественный тип данных называют еще денежным. С его помощью осуществляется реализация различных приложений финансовой тематики. Имеет 53 бита точности и поддержку 4 десятичных мест.

Текстовую информацию(переменные) представляют строковые типы данных в Delphi. Различают 3 типа:

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

В delphi строковые типы данных допускается обозначать типом string, который аналогичен shortstring.

Синтаксис указания типа переменной в delphi довольно просто. Ряд примеров подтверждает это утверждение:

Var Stroka: longstring; -Задаем переменной “Stroka” тип longstring. var D: double; - вещественный тип данных. var F: shortint; - целочисленный тип.
Язык Delphi является производным от низкоуровневого языка Object Pascal, что позволяет разрабатывать с использованием совместимых компиляторов программы под Linux. Такое положение обеспечивает написание программ, разработку графических интерфейсов, приложений, способных облегчить администрирование linux, насытить систему новым и удобным функционалом.

Тип данных

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

Целый тип

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

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

	Тип	Диапазон	Формат
	Shortint	128-127	8 битов
	Smallint	32 768 - 32 767	16 битов
	Longint	2 147 483 648 - 2 147 483 647	32 бита
	Int64	2 63 - 2 63 - 1	64 бита
	Byte	0-255	8 битов, беззнаковый
	Word	0-65 535	16 битов, беззнаковый
	Longword	0 - 4 294 967 295	32 бита, беззнаковый

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

Вещественный тип

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

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

	Тип	Диапазон	Значащих цифр	Байтов
	Real48	2.9x 10 -39 -1.7x10 38	11-12	06
	Single	1.5 x 10 -45 -3.4х 10 38	7-8	04
	Double	5.0x10- 324 -1.7x10 308	15-16	08
	Extended	3.6x10- 4951 -1.1 х10 4932	19-20	10
	Comp	2 63 +1 - 2 63 -1	19-20	08
	Currency	922 337 203 685 477.5808 --922 337 203 685 477.5807	19-20	08

Язык 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 обозначают одну и ту же переменную.

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

ах2 + bх + с = 0

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

TotalSumm и Discount или ObSumma и Skidka.

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

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

Имя: тип;

где:

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

Пример:

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

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

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

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

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

Константы

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

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

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

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

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

123 0.0

524.03 0

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

"2.4"

"Д"

Здесь следует обратить внимание на константу " 2.4". Это именно символьная константа, т. е. строка символов, которая изображает число "две целые четыре десятых", а не число 2,4.

Логические константы

Логическое высказывание (выражение) может быть либо истинно, либо ложно. Истине соответствует константа True, значению "ложь" - константа False.

Именованная константа

Именованная константа - это имя (идентификатор), которое в программе используется вместо самой константы.

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

константа = значение;

где:

• константа - имя константы;
  
• значение - значение константы.
  

Именованные константы объявляются в программе в разделе объявления констант, который начинается словом const. Ниже приведен пример объявления именованных констант (целой, строковой и дробной).

const

Bound = 10;

Title = "Скорость бега";

pi = 3.1415926;

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

В отличие от переменной, при объявлении константы тип явно не указывают. Тип константы определяется ее видом, например:

• 125 - константа целого типа;
  
• 0.0 - константа вещественного типа;
  
• " выполнить " - строковая константа;
  
• " \" - символьная константа.

Продолжаем наше обучение! В 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 : 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 .

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