Типы данных языка паскаль. Простые типы

	Простые типы


Порядковые	Вещественные	Дата-время

Логические

Символьный

Перечисляемый

Тип-диапазон

Рисунок 1 – Простые типы данных

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

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

Функции, предназначенные для работы с порядковыми типами, приведены в таблице 1.

Таблица 1 – Функции для работы с порядковыми типами.

Целые типы

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

Таблица 2 – Целочисленные типы
Наименование	Длина, байт	Диапазон значений
Наименование	Длина, байт	Диапазон значений


				2147483648 … +2147483647
				0 … 2147483647
				0 … 4294967295
				263 … 263 -1

Обратите внимание на то, чтоObject Pascal осуществляет автоматическое приведение типов. Например, там, где в качестве аргумента допустимо использовать переменную типа Word, допускается использовать переменную типа Byte, но не наоборот. Общее правило таково вместо одного типа целочисленной переменной можно использовать другой тип целочисленной переменной если их диапазоны значений вкладываются друг

в друга.

В таблице 3 приведены некоторые функции для работы с целочисленными переменными.

Таблица 3 – Функции для работы с целыми числами

При действиях с целыми числами тип результата будет соответствовать типу операндов, а если операнды относятся к различным целым типам, – общему типу, который включает в себя оба операнда. Например, для типов ShortInt и Word общим типом будет Integer.

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

Листинг 1

{$IFDEF FPC} {$MODE DELPHI}

{$APPTYPE CONSOLE} program InOutPrg; var x: Word; begin

Для того чтобы включить контроль переполнения, необходимо указать директиву компилятора {$Q+} для отключения контроля – {$Q-}.

Вместо {$Q+} можно использовать{$OVERFLOWCHECKS ON} , а вместо {$Q-} {$OVERFLOWCHECKS OFF}

Измените программу, приведенную в листинге 1, поместив в нее директиву{$Q+} первой строкой. Запустите ее на выполнение, программа должна аварийно завершиться.

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

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

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

Переменная логического типа может принимать только два значения True (истина) и False (ложь). Логические типы приведены в таблице 4.

Таблица 4 – Логические типы

Для работы с логическими типами используйте тип Boolean, остальные типы были добавлены в Object Pascal для совместимости с программами написанными на других языках программирования.

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

Символьный тип, как следует из его названия, предназначен для хранения кода символа. Внутренняя структура типа совпадает с внутренней структурой беззнаковых целых чисел. Object Pascal поддерживает два символьных типаAnsiChar иWideChar. Характеристики этих типов приведены в таблице5.

Таблица 5 – Символьные типы

		Описание


		Код символа в кодировке ANSI. Таблица символов этого стандарта
		состоит из 256 символов, причем первые 128 символов жестко
		определены стандартом, а остальные 128 могут содержать любые
		символы. Во вторую часть кодовой таблицы обычно помещают
		символы национальных алфавитов. Недостатком данного
		представления символов является то, что невозможно отображение
		сразу символов более
		чем 2-х алфавитов.
		Символ в формате UNICODE. Таблица символов содержит 65536
		символов. В данной таблице находятся символы всех алфавитов.
Char1		Является псевдонимом типа AnsiChar

Для преобразования кода символа в символ следует применять следующую функцию

function chr(X:byte):char

Для обратного преобразования используется функция

1 В Object Pascal тип Char является основным. В следующих версиях тип Char может стать псевдонимом для типа WideChar.

function ord(X:char):byte;

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

ch:="A" ;

ch:=#97; //97 – код символа "A".

Например

var ch:char; code: byte;

begin ch:="A" ;

ch:=chr(32); //32 - соответствует коду клавиши пробел

end.

Перечисляемый тип

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

<имя типа> = (id, id, id,...);

Здесь «имя типа» – идентификатор Object Pascal , «id» – идентификаторObject Pascal .

Например, тип описывающий некоторый фиксированный набор цветов

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

type TColors = (red, green, white, yellow);

TDays=(monday, tuesday, wednesday);

Определены переменные

var col:TColors;

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

col:=Succ(green);

day:=Pred(tuesday);

но не допустимы

Максимальное количество перечисляемых значений зависит от реализации. В настоящее время размер переменной перечисляемого типа равен 4 байта, что соответствует 232 различных значений, т. е. во внутреннем представлении перечисляемый тип представляет собой тип LongWord.

Как говорилось выше , можно поместить определение типа сразу, после двоеточия, например

var col: (red, green, white, yellow); day: (monday, tuesday, wednesday);

Тип-диапазон

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

<мин. зн.> .. <макс. зн.>

Глава II. Типы данных.

§7. Типы данных. Порядковые типы языка Pascal.

Типы данных.

Во втором параграфе мы немного узнали о типах данных. Это было необходимо, что бы начать программировать. В данном параграфе мы подробно рассмотрим все типы данных существующие в Pascal.

Для начала выясним, что такое сам термин «типы данных». Для этого перечислим ряд аспектов, некоторые из которых уже были приведены во втором параграфе.

Память в компьютере состоит из элементарных ячеек, в которых может содержаться только единичка или нолик. У каждой ячейки существует свой уникальный адрес. Размер памяти в одну ячейку называется битом. Размер памяти в 8 ячеек называется байтом. 1024 байта составляют килобайт. А 1024 килобайта составляют один мегабайт. 1024 мегабайта – один гигабайт, а 1024 гигабайта – один тиробайт.

У вас должен возникнуть уместный вопрос: почему в одном килобайте 1024 байта. Дело в том, что приставка, например, кило в обычной жизни обозначает, что число надо помножить на тысячу. Например, 5 километров – это 5000 метров. А вот при обозначении количества памяти приставка кило обозначает, что число надо помножить на 1024. Такое число возникло не просто случайно, оно равно двум в степени десять – . В своё время первые программисты договорились и решили объём памяти в 1024 байта называть одним килобайтом. Соответственно 1 килобайт, помноженный на один килобайт, будет равен одному мегабайту. А один мегабайт, помноженный на один мегабайт, будет равен одному гигабайту. И так далее.

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

Для примера можем посчитать, сколько элементарных ячеек содержится в оперативной памяти в один гигабайт. Один гигабайт – это 1024 мегабайта. Один мегабайт – это 1024 килобайта. Соответственно в одном гигабайте содержится 1024 х 1024 = 1048576 килобайт. Ещё раз помножим на 1024 и получим 1073741824 байта. Помножим это число на 8 – получим 8589934592 бит. Вот столько элементарных ячеек памяти содержится в оперативной памяти объёмом в один гигабайт.

Двигаемся дальше. Представим себе, что нам необходимо обработать 24 элементарных ячейки памяти, или говоря другими словами 24 бита. Содержание этих ячеек можно представить в виде списка. Например, он может быть таким:

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

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

00000001 00000010 00010100 00001101

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

В принципе мы можем читать этот список как угодно. Можно по два бита можно по одному или по пять. Обозначать этот список может тоже всё, что угодно, главное, мы должны заранее договориться о том, как его читать и что он будет обозначать.

Именно такая договорённость и есть типы данных. Т.е. используя определённый тип мы «договариваемся с компьютером», что определённое количество бит, будут обозначать определённое число или букву, или ещё что-то другое.

О двоичных цифрах сейчас мы говорить не будем, потому что на данном этапе в этом нет необходимости. Главное вы должны усвоить, что если вы хотите использовать, допустим, целое число, то вы должны выбрать тип целых чисел, если какое-либо дробное число, то тип real, если символ, то тип char и так далее.

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

Данной схемой вы можете пользоваться на первый порах, для выбора нужного типа, в дальнейшем она запомниться сама собой. А так же логика объединения типов в группы так же станет вам понятна.

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

Особенностью порядковых типов является то, что переменная любого порядкового типа имеет конечное число возможных значений и то, что несколько переменных какого-либо порядкового типа можно расположить в порядке убывания или возрастания, т.е. упорядочить (отсюда и название). А так же то, что только переменные порядковых типов могут быть параметром цикла For to do.

Целые типы.

Как уже было сказано, переменная целого типа содержит в себе целое число. Мы изучили уже тип целых чисел Byte. Переменная такого типа может содержать в себе целое число от 0 до 255 включительно. Занимает оно в памяти компьютера 1 байт. Если нам понадобиться отрицательное число или число больше 255, тогда мы можем использовать тип Integer. Переменная такого типа может содержать в себе целые числа от -32768 до +32767 включительно. Однако такая переменная будет занимать в памяти 2 байта.

Название	Перевод названия на русский	Размер занимаемой памяти в байтах	Диапазон значений
Название	Перевод названия на русский	Размер занимаемой памяти в байтах	от	до
Byte	Байт
ShortInt	Короткое целое
Word	Слово			65 535
Integer	Целое		32 768	32 767
LongInt	Длинное целое		2 147 483 648	2 147 483 647

Для удобства запоминания в таблице приведён перевод названий типов. В столбце диапазон значений приведённые числа входят в этот диапазон. Например, переменная типа Integer может содержать в себе число 32 767, а вот число 32768 уже не может.

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

Так же стоит отметить, что операции с большими числами могут занимать больше времени, чем с маленькими. Поэтому не следует использовать, например, тип LongInt, если вы заведомо знаете, что переменная не будет принимать значения больше 32 767.

Конечно в небольшой программе, которая будет работать на мощном современном компьютере, выбор не соответствующего типа (большего по размеру), ни как не скажется на работе этой программы, однако в больших программах эта оплошность может сказаться на быстродействии программы в целом. Например, пользователь будет ждать результата не 3 секунды, а 10. Конечно, если он его ждёт один раз в день то особо он не расстроится, а если он в течение всего дня должен получать результаты, то представьте, на сколько больше результатов он получить, если вы правильно выберите тип данных. То же самое относится и к типам данных, которые будут изучены позже.

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

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

div – целочисленное деление. (Получаем значение от деления как бы без дробной части);

mod – получение остатка от целочисленного деления.

Все мы умеем делить столбиком. Для понимания этих двух операций можно привести следующий рисунок:

Если использовать запись как в обычной математике, то:

9 div 4 = 2;

i,f: Integer ;

begin

Writeln("Введите два целых числа" );

Read(i,f);

Writeln(i, "/" ,f, "=" ,i div f, " остаток " ,i mod f);

end .

____________________________________________________

Введите два целых числа

13/5=2 остаток 3

Так же есть ещё одна функция для работы с целыми типами – Odd, которая возвращает True, если число нечётное и False, если число чётное. Пример:

var i: integer ;

begin

i:= 10 ;

If odd(i) then writeln("Число " ,i, " - нечётное." )

else writeln("Число " ,i, " - чётное." );

end .

___________________________________________________

Число 10 - чётное.

Стоит отметить следующий нюанс: если переменная целого типа имеет последнее значение диапазона, то при увеличении этой переменной на единицу она примет первое значение диапазона. И наоборот – если первое значение, то при уменьшении на единицу – последнее. Например, если переменная А типа Byte имеет значение 255, тогда А+1 будет равно 0. Или если увеличить на два, то А+2=1. Ещё пример: если А=250, то А+20=14. Ещё пример, если А=0, то А-1=255. В таких ситуациях компилятор ошибку не выдаёт. При выполнении программы ошибки тоже не будет. Просто вы получите не правильное значение. Это обстоятельство так же должно быть критерием выбора правильного типа.

Как уже было сказано, в цикле For to do можно использовать переменную любого порядкового типа. Однако есть один нюанс. Если вы укажете после слова to число, выходящее за рамки возможных значений типа переменной, стоящей после слова For, то этот цикло не будет выполнен ни разу вообще. В данной ситуации только будет выполнен оператор присваивания находящийся после слова For, причём никаких сообщений об ошибках вы не получите. Например:

b: byte ;

begin

b:= 2 ;

Writeln(b);

For b:=- 5 to 5 do Writeln(b);

Writeln(b);

end.

______________________________

Обратите внимание, что код цикла выполнен не был, а переменной b было присвоено значение 251. Что произошло? В цикле For to do мы попытались присвоить переменной b значение, выходящее за рамки «рабочего» диапазона типа byte. Что сделал компьютер? Он, как бы, выполнил следующее арифметическое выражение: b=0-5. И произошло то, что было описано в предыдущем абзаце. Т.е. b стало равно 251, как это видно из результата работы программы.

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

Вывод целых чисел в виде таблицы.

Рассмотрим задачу, которая сформулирована следующим образом: необходимо вывести на экран таблицу чисел от 1 до 100. В каждой строчке должно находиться по 10 чисел, соответственно должно получиться 10 столбиков.

Для решения задачи будем рассуждать следующим образом: мы можем с помощью процедур write и writeln вывести каждое число в отдельности в нужной последовательности. Однако нам необходимо, автоматизировать этот процесс, и что бы код занимал, как можно меньше строчек. Поэтому нам необходимо использовать цикл. В данной ситуации, при работе с целыми числами, наилучшим образом подходит цикл For to do.

Попробуем с помощью этого цикла вывести десять чисел от 1 до 10 в одну строчку:

var i: integer ;

begin

For i:= 1 to 10 do

write(i: 4 );

end .

________________________________________

1 2 3 4 5 6 7 8 9 10

Обратите внимание, что для вывода переменной i на экран задано 4 символа. Это для того, что бы последнее число 100 было отделено от предыдущего 99 одним пробелом.

Мы организовали автоматический вывод 10 чисел в одну строчку. Теперь надо подумать, как вывести все 100 чисел. Для этого нам необходимо после вывода каждых новых десяти чисел переходить на новую строчку. Сделаем это по следующему условию: если число делиться без остатка на 10, то вызываем процедуру Writeln:

var i: integer ;

begin

For i:= 1 to 100 do

Begin

write(i: 4 );

if (i mod 10 ) = 0 then writeln;

end ;

end .

_________________________________________

1 2 3 4 5 6 7 8 9 10

11 12 13 14 15 16 17 18 19 20

21 22 23 24 25 26 27 28 29 30

31 32 33 34 35 36 37 38 39 40

41 42 43 44 45 46 47 48 49 50

51 52 53 54 55 56 57 58 59 60

61 62 63 64 65 66 67 68 69 70

71 72 73 74 75 76 77 78 79 80

81 82 83 84 85 86 87 88 89 90

91 92 93 94 95 96 97 98 99 100

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

В данном параграфе мы разобрали, что такое типы данных. Узнали, какие типы существуют в Pascal. Изучили целые типы и научились автоматически выводить список на экран.

Задачи.

1. Пользователь вводит целое число, не используя функцию Odd, определить, является число чётным или нет.

2. Имеем 4 числа. В первой строчке вывести числа, которые делятся на 3 без остатка, во второй – которые делятся на три с остатком. Если чисел, которые делятся без остатка или делятся с остатком, нет, то вывести соответствующее сообщение. В третьей строчке под числом, которое делится с остатком вывести остаток от деления на 3.

3. Составьте свою функцию определения чётное число или нет на основе операции mod, а так же программу, демонстрирующую пример использования этой функции.

4. Вывести на экран только чётные числа от 1 до 100 в виде таблицы. В таблице должно быть 9 столбиков.

Решение.

var i: integer ;

begin

writeln("Введите целое число." );

Read(i);

if (i mod 2 )= 0 then writeln("Число " ,i, " - чётное." )

end .

______________________________________________________

Введите целое число.

Число 57 - нечётное.

var i,k,l,m: integer ;

S1,s2: longint ;

begin

i:= 3 ;k:= 45 ;l:= 21 ;m:= 1 ;

Writeln("Имеем следующие числа: " ,i, " " ,k, " " ,l, " " ,m);

S1:= 0 ;s2:= 0 ;

if (i mod 3 ) = 0 then s1:=s1+ 1 else s2:=s2+ 1 ;

if (k mod 3 ) = 0 then s1:=s1+ 1 else s2:=s2+ 1 ;

if (l mod 3 ) = 0 then s1:=s1+ 1 else s2:=s2+ 1 ;

if (m mod 3 ) = 0 then s1:=s1+ 1 else s2:=s2+ 1 ;

if s1 = 0 then write("Чисел, которые делятся на 3 без остатка нет." )

else write("Делятся на 3 без остатка: " );

if (i mod 3 ) = 0 then write(i, " " );

if (k mod 3 ) = 0 then write(k, " " );

if (l mod 3 ) = 0 then write(l, " " );

if (m mod 3 ) = 0 then write(m, " " );

Writeln;

if s2 = 0 then write("Чисел, которые делятся на 3 с остатком нет." )

else write("Делятся на 3 с остатком: " );

if (i mod 3 ) <> 0 then write(i: 4 );

if (k mod 3 ) <> 0 then write(k: 4 );

if (l mod 3 ) <> 0 then write(l: 4 );

if (m mod 3 ) <> 0 then write(m: 4 );

Writeln;

Write(" остаток: " );

if (i mod 3 ) <> 0 then write((i mod 3 ): 4 );

if (k mod 3 ) <> 0 then write((k mod 3 ): 4 );

if (l mod 3 ) <> 0 then write((l mod 3 ): 4 );

if (m mod 3 ) <> 0 then write((m mod 3 ): 4 );

end .

_________________________________________________________________________

Имеем следующие числа: 3 45 21 1

Делятся на 3 без остатка: 3 45 21

Делятся на 3 с остатком: 1

Остаток: 1

Function chetnost(i: integer ): boolean ;

begin

If (i mod 2 )= 0 then chetnost:= True

else chetnost:= False ;

end ;

Var i: integer ; b: boolean ;

begin

writeln("Введите целое число" );

Read(i);

B:=chetnost(i);

if b then writeln("Число " ,i, " - чётное." )

else writeln("Число " ,i, " - нечётное." );

end .

_____________________________________________

Введите целое число

Число 3 - нечётное.

var i: integer ;

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

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

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

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

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

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

Рис. 1.1

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

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

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

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

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

то функция PRED(с) вернет символ "4", а функция SUCC(с) - символ "6".

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

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

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

Название	Длина, байт	Диапазон значений
		0. .. 2 147 483 647


		32 768...+32 767


		2 147 483 648...+2 147 483 647
		91018...+91018
		0. . .4 294 967 295

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

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

Перечень процедур и функций, применимых к целочисленным типам, приведен в табл. 1.2. Буквами b, s, w, i, l обозначены выражения соответственно типа Byte, Shortint, Word, Integer и Longint,

х - выражение любого из этих типов; буквы vb, vs, vw, vi, vl, vx обозначают переменные соответствующих типов. В квадратных скобках указывается необязательный параметр.

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

Обращение	Тип результата	Действие
		Возвращает модуль x
		Возвращает символ по его коду
		Уменьшает значение vx на i, а при отсутствии i - на 1
		Увеличивает значение vx на i, а при отсутствии i -на 1
		Возвращает старший бант аргумента
		Возвращает третий по счету байт
		Возвращает младший байт аргумента

		Возвращает True, если аргумент-нечетное число
	Как у параметра	Возвращает псевдослучайное число, равномерно распределенное в диапазоне 0...(w-l)
		Возвращает квадрат аргумента
		Меняет местами байты в слове

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

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

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

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

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

for L:= False to True do

ShowMessage ("--);

Если заменить тип параметра цикла L в предыдущем примере на Boolean, цикл будет работать и сообщение дважды появится на экране. [Для Delphi версии 1 и 2 ord (True) =+1 для любого логического типа.]

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

Для кодировки в Windows используется код ANSI (назван по имени American National Standard Institute - американского института стандартизации, предложившего этот код). Первая половина символов ПК с кодами 0... 127 соответствует таблице 1.3. Вторая половина символов с кодами 128...255 меняется для различных шрифтов. Стандартные Windows-шрифты Arial Cyr, Courier New Cyr и Times New Roman для представления символов кириллицы (без букв “ё” и “Ё”) используют последние 64 кода (от 192 до 256): “А”... “Я” кодируются значениями 192..223, “а”... “я” - 224...255. Символы “Ё” и “ё” имеют соответственно коды 168 и 184.

Таблица 1.3 - Кодировка символов в соответствии со стандартом ANSI

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

К типу char применимы операции отношения, а также встроенные функции:

Сhаr (в) - функция типа char; преобразует выражение в типа Byte в символ и возвращает его своим значением;

UpCase(CH) - функция типа char; возвращает прописную букву, если сн - строчная латинская буква, в противном случае возвращает сам символ сн (для кириллицы возвращает исходный символ).

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

colors = (red, white, blue);

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

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

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

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

Тип-диапазон задается границами своих значений внутри базового типа:

<мин.знач.>..<макс.знач.>

Здесь <мин. знач. > - минимальное значение типа-диапазона; <макс. знач. > - максимальное его значение.

Тип-диапазон не обязательно описывать в разделе type, а можно указывать непосредственно при объявлении переменной.

При определении типа-диапазона нужно руководствоваться следующими правилами:

два символа “..” рассматриваются как один символ, поэтому между ними недопустимы пробелы; левая граница диапазона не должна превышать его правую границу.

Тип-диапазон наследует все свойства своего базового типа, но с ограничениями, связанными с его меньшей мощностью. В частности, если определена переменная.

В стандартную библиотеку Object Pascal включены две функции, поддерживающие работу с типами-диапазонами:

High(х) - возвращает максимальное значение типа-диапазона, к которому принадлежит переменная х;

Low (х) - возвращает минимальное значение типа-диапазона.

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

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

Таблица 1.4 - Вещественные типы

В предыдущих версиях Delphi 1...3 тип Real занимал 6 байт и имел диапазон значений от 2,9*10-39 до 1,7*1038. В версиях 4 и 5 этот тип эквивалентен типу Double. Если требуется (в целях совместимости) использовать 6-байтных Real, нужно указать директиву компилятора {SREALCOMPATIBILITY ON}.

Как видно из табл. 1.4, вещественное число в Object Pascal занимает от 4 до 10 смежных байт и имеет следующую структуру в памяти ПК.

Здесь s - знаковый разряд числа; е - экспоненциальная часть; содержит двоичный порядок; m - мантисса числа.

Мантисса m имеет длину от 23 (для single) до 63 (для Extended) двоичных разрядов, что и обеспечивает точность 7...8 для single и 19...20 для Extended десятичных цифр. Десятичная точка (запятая) подразумевается перед левым (старшим) разрядом мантиссы, но при действиях с числом ее положение сдвигается влево или вправо в соответствии с двоичным порядком числа, хранящимся в экспоненциальной части, поэтому действия над вещественными числами называют арифметикой с плавающей точкой (запятой).

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

Особое положение в Object Pascal занимают типы comp и Currency, которые трактуются как вещественные числа с дробными частями фиксированной длины: в comp дробная часть имеет длину 0 разрядов, т. е. просто отсутствует, в currency длина дробной части -4 десятичных разряда. Фактически оба типа определяют большое целое число со знаком, сохраняющее 19...20 значащих десятичных цифр (во внутреннем представлении они занимают 8 смежных байт). В то же время в выражениях comp и currency полностью совместимы с любыми другими вещественными типами: над ними определены все вещественные операции, они могут использоваться как аргументы математических функций и т. д. Наиболее подходящей областью применения этих типов являются бухгалтерские расчеты.

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

Тема 3. Структура типов данных. Стандартные процедуры и функции, применимые к целым, вещественным числам. Логический, символьный, перечисляемый типы, тип-диапазон. Примеры.

Типы данных

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

Турбо Паскаль характеризуется разветвлённой структурой типов данных.

Простые типы

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

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

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

К порядковым типам относятся целые, логический, символьный, перечисляемый и тип – диапазон. Функция ORD(X) возвращает порядковый номер значения выражения X и применяется к любому порядковому типу. Для целых типов функция возвращает само значение X, т.е. ORD(X)=X для X, принадлежащего любому целому типу.

ORD(X) для символьного типа даёт целое число в диапазоне от 0 до 255, для перечисляемое типа ORD(X) даёт число в диапазоне от 0 до 65535. Тип- диапазон сохраняет все свойства базового порядкового типа, поэтому результат применения к нему функции ORD(X) зависит от свойств этоготипа. К порядковым типам можно также применять функции:

PRED (X)- возвращает предыдущее значение порядкового типа, т.е. ORD(PRED (X))= ORD(X)-1;

SUCC(X)- возвращает следующее значение порядкового типа, (которое соответствует порядковому номеру ORD (X)+1), т.е.

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

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

Например:

n:integer;

Паскаль - статический язык, из этого следует, что тип переменой определяется при ее описании и не может быть изменен. Язык Паскаль имеет развитую систему видов - все данные должны принадлежать заранее известному типу данных (либо стандартному типу, созданному при разработке языка или пользовательскому типу, который определяет программист). Программист может создавать свои типы произвольной структурой сложности на основе стандартных типов, либо уже определенных пользователем типов. Количество создаваемых типов неограниченно. Пользовательские типы в программе объявляется в разделе TYPE по формату:

[имя] = [тип]

Система стандартных типов имеет разветвленную, иерархическую структуру.

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

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

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

Процедурные типы являются нововведением языка Turbo Pascal, и они позволяют обращаться к подпрограммам, как к переменным.

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

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

При использовании целочисленных чисел следует руководствоваться вложенностью типов, т.е. типы с меньшим диапазоном могут быть вложены в типы с большим диапазоном. Тип Byte может быть вложен во все типы занимающие 2 и 4 байта. В тоже время тип Short Int, занимающий 1 байт не может быть вложен в тип Word, поскольку не имеет отрицательных значений.

Можно выделить 5 вещественных типов:

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

2358.8395

0.23588395*10 4

0.23588395*E 4

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

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

Порядковые типы объединяют в себе несколько простых типов. К ним относятся:

все целые типы;
символьный тип;
логический тип;
тип-диапазон;
перечисляемый тип.

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

К значениям порядкового типа может быть применена функция ODD(x), которая возвращает порядковый номер аргумента x.

Функция PRED(x) - возвращает предшествующее значение порядкового типа. PRED(A) = 5.

Функция SUCC (x) - возвращает следующее значение порядкового типа. SUCC(A) = 5.

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

Значениям символьного типа является 256 символов из множества допустимых кодовой таблицей используемого компьютера. Начальная область этого множества, то есть диапазон от 0 до 127 соответствует множеству кодов ASCII, куда загружаются символы алфавита, арабских чисел и специальных символов. Символы начальной области всегда присутствуют на клавиатуре ПК. Старшая область называется альтернативной, она содержит символы национальных алфавитов и различные специальные символы, и символы псевдографики, не соответствующие коду ASCII.

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

C:= ’A’

Логический (булевский) тип

Имеются два значения булевского типа: Истина (True) и Ложь (False). Переменные данного типа задаются служебным словом BOOLEAN. Значение булевского типа занимают один байт в оперативной памяти. Значениям Истина и Ложь соответствуют числовые значения 1 и 0.

Тип-диапазон

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

[минимальное-значение]…[максимальное-значение]

Тип-диапазон можно задавать в разделе Type, как определенный тип, а можно непосредственно в разделе Var.

При определении тип-диапазона необходимо руководствоваться:

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

Перечисляемый тип

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

Peoples = (men, women);

Первое значение - 0, второе значение - 1 и т.д.

Максимальная мощность 65535 значений.

Строковый тип

Строковый тип относится к группе структурированных типов и состоит из базового типа Char. Строковый тип не относится к порядковым типам. Он определяет множество символьных цепочек произвольной длины до 255 символов.

В программе строковый тип объявляется, словом String. Поскольку String является базовым типом, он описан в языке и объявление переменной типа String осуществляется в Var. При объявлении переменной строкового типа за String в квадратных скобках целесообразно указывать длину строки. Для указания используется целое число от 0 до 255.

Fam: String;

Указание длины строки позволяет компилятору отвести под данную переменную указанное число байтов в ОЗУ. Если длина строки не указана, то в этом случае компилятор отведет под значение этой переменной максимальное возможное число байт (255).