Порядковый тип. Порядковые типы данных в паскале
Простые типы | |||||
Порядковые | Вещественные | Дата-время |
|||
Логические
Символьный
Перечисляемый
Тип-диапазон
Рисунок 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);
Тип-диапазон
Тип диапазон представляет собой подмножество некоторого базового порядкового типа. Типдиапазон задается границами своих значений.
<мин. зн.> .. <макс. зн.>
ПОРЯДКОВЫЙ ТИП
линейно упорядоченного множества А -
свойство множества А,
к-рое присуще любому линейно упорядоченному множеству В,
подобному А.
При этом два множества Аи В,
линейно упорядоченные соотношениями R и S, наз. подобными, если существует f, взаимно однозначно отображающая Ана Ви такая, что для любых точек выполнено xRy
f(x)Sf
(y).
Г. Кантор (G. Cantor) определял П. т. как такое свойство линейно упорядоченного множества, к-рое остается, если отвлечься лишь от свойств элементов этого множества, но не от их порядка. Чтобы подчеркнуть, что проведен один этот акт абстракции, Г. Кантор для обозначения П. т. множества Аввел символ . Для часто встречающихся множеств их П. т. обозначается специальными буквами. Напр., если - множество всех натуральных чисел, упорядоченное отношением , то . Если - множество всех рациональных чисел, также упорядоченное отношением , то . Линейно Аимеет тип w тогда и только тогда, когда: (1)Аимеет первый элемент а 0 , (2) каждый элемент хмножества Аимеет последующий x+l, (З) если и множество Xсодержит последователь каждого своего элемента, то Х=А.
Существует только один П.
т. h.
непустых множеств, плотных, счетных, не имеющих ни первого, ни последнего элемента ( Кантора). Линейно упорядоченное множество имеет П. т. l - множества всех действительных чисел, если оно непрерывно и содержит плотное в нем подмножество А,
П. т. к-рого есть h, имеющее с ним общее начало и общий конец. Доказана в системе аксиом (ZF
) Суслина проблемы,
см. .
Для П. т. определяются операции, до нек-рой степени аналогичные арифметич. операциям.
Пусть a и b - два П. т., A и В -
такие два линейно упорядоченные множества, что 
и . Суммой a+b наз. П. т. 
, где множество упорядочено так, что все элементы множества Апредшествуют всем элементам множества В,
а в каждом из множеств А к В
порядок сохраняется. В частности, если a и b - натуральные числа, то определение суммы П. т. совпадает с определением суммы натуральных чисел. Имеют место равенства (a+b)+g=a+(b+g) и a+0=a=0+a, где 0 - Н. т. пустого множества. Закон коммутативности в общем случае не выполняется, напр.
Пусть 
. Произведением наз. П. т. 
, где множество упорядочено так, что если { х, у
},
{x l , y 1
} - два его элемента, то первый элемент предшествует второму, когда y
Где 1 - П. т. одноэлементного множества. Умножение, как и , некоммутативно. Напр., . Закон дистрибутивности выполняется: Произведение представляет непрерывный П. т. мощности континуума, не содержащий счетного плотного подмножества.
С суммой и произведением П. т. тесно связаны сумма произвольного упорядоченного множества П. т. и лексикографич. вполне упорядоченного множества П. т. Пусть 
- семейство линейно упорядоченных множеств, индексированное вполне упорядоченным множеством М,
и - декартово произведение этого семейства.
Лексикографическим произведением семейства наз. множество А,
наделенное следующим порядком. Если { а т
}и {b т
}элементы из А,
то { а т
}<
{b т
}тогда и только тогда, когда или a 1
<b 1
или существует такое, что а т =b т
для всех m
, то наз. произведением семейства П. т. 
. С помощью лексикографич. произведения и обобщенной континуум-гипотезы
построено для каждого кардинального числа
t такое линейно упорядоченное множество h t мощности t, что каждое линейно упорядоченное множество мощности подобно нек-рому подмножеству множества h t . Если t является сильно недостижимым кардинальным числом, то обобщенная континуум-гипотеза для доказательства этой теоремы не нужна. В частности, для таким множеством является любое линейно упорядоченное множество П. т. h.
Лит. : Иех Т., Теория множеств и метод форсинга, пер. с англ., М., 1973. Б. А. Ефимов.
Математическая энциклопедия. - М.: Советская энциклопедия . И. М. Виноградов . 1977-1985 .
Тип данных
Совместимость типов
Конструируемые типы данных
Вещественные типы данных
Порядковые типы данных
Тип данных
План
Лекция 8
Тема: Тип данных
Компиляторы языка Pascal требуют, чтобы сведения об объёме памяти, необходимой для работы программы, были предоставлены до начала её работы. Для этого в разделе описания переменных (var) нужно перечислить все переменные, используемые в программе. Кроме того, необходимо также сообщить компилятору, сколько памяти каждая из этих переменных будет занимать. А ещё было бы неплохо заранее условиться о различных операциях, применимых к тем или иным переменным...
Всё это можно сообщить программе, просто указав тип будущей переменной. Имея информацию о типе переменной, компилятор «понимает», сколько байт необходимо отвести под неё, какие действия с ней можно производить и в каких конструкциях она может участвовать.
Тип определяет множество допустимых значений, которые может иметь тот или иной объект, а также множество допустимых операций, которые применимы к нему. Кроме того, тип определяет также и формат внутреннего представления данных в памяти ПК.
Базовые типы данных являются стандартными, поэтому нет нужды описывать их в разделе type. Однако при желании это тоже можно сделать, например, дав длинным определениям короткие имена. Скажем, введя новый тип данных
Type Int = Integer;
можно немного сократить текст программы.
Разделение на базовые и конструируемые типы данных в языке Pascal показано в таблице:
Среди базовых типов данных особо выделяются порядковые типы. Такое название можно обосновать двояко:
1. Каждому элементу порядкового типа может быть сопоставлен уникальный (порядковый) номер. Нумерация значений начинается с нуля. Исключение - типы данных ShortInt, Integer и LongInt. Их нумерация совпадает со значениями элементов.
2. Кроме того, на элементах любого порядкового типа определён порядок (в математическом смысле этого слова), который напрямую зависит от нумерации. Таким образом, для любых двух элементов порядкового типа можно точно сказать, который из них меньше, а который - больше 2 .
Глава 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 ;
D Pascal существенно расширяет CF Pascal добавлением новых типов данных к символам и файлам. Порядковые типы данных описывают простые, неделимые объекты. Перечислимый тип содержит фиксированный набор именованных объектов. Логический тип имеет только два объекта – TRUE и FALSE. Целый тип реализует положительные и отрицательные целые числа. Наконец, часть типа также в свою очередь может быть типом, типом диапазон. Конечно, типы включают операции, которые определяют, что может быть сделано с объектами. Для логического, целого и т.д. эти операции хорошо понятны интуитивно.
Типы данных описывают множества значений и операции, которые могут быть применены к ним. Типы данных введенные CF Pascal это CHAR и TEXT. Значениями типа CHAR являются множество допустимых символов Паскаль-машины и операциями над этими значениями являются операторы сравнения:
= < > <= >= <>
значениями которых являются соответствующие математические операции, отражающие различное положение символов в алфавитной последовательности. Значения типа данных TEXT – последовательности строк, каждая строка является последовательностью символов. Операции над такими данными:
RESET REWRITE READ WRITE WRITELN OEF EOLN
Типы данных предлагают преимущества абстрагирования , репликации и аутентификации .
Типы данных абстрагируют важные свойства данных. Например, для понимания сравнения
‘A’ < ‘B’
нет необходимости знать, как эти символы представлены в Паскаль-машине. Последовательность сортировки определяет значение этих операций. Пользователю нет необходимости знать количество битов, которыми представлено символьное значение, что происходит с избыточными битами, действительно ли битовое значение для символа B больше чем для A и т.д.
Модули реализуют разновидность абстракции данных, но типы данных предлагают нечто большее. Объявление переменных типа данных позволяет хранить и манипулировать любым количеством значений типа через эти переменные. Каждое использование переменной в программе дает нам гарантию, что к ней будут применены только допустимые операции.
Контекст операнда в программе подразумевает тип операнда, этот подразумеваемый тип – избыточная информация, которая может быть проверена на соответствие объявленному типу операнда для предотвращения операций над значениями неверного типа. Рассмотрим следующий фрагмент программы:
PROGRAM Typex(INPUT, OUTPUT);
Поскольку операция = определена в CF Pascal только для символьных операндов, появление Ch и F в качестве операндов подразумевает, что оба они типа CHAR. У Ch тип корректен, а F объявлена как TEXT, поэтому будет выявлено несоответствие.
В D Pascal существует две разновидности типов данных: простые типы данных и составные (aggregate) типы данных. Значения простых типов не могут состоять из более мелких частей, с которыми можно работать по отдельности. CHAR – простой тип. Значения сложных типов данных образованы объединением значений простых типов. TEXT – составной тип, потому что строки фалов состоят из символов.
Значения простых типов упорядочены, то есть для каждой пары значений этого типа x, y возможен только один из вариантов: x < y, x = y, x > y. Поэтому эти типы называются порядковыми.
Паскаль содержит три предопределенных порядковых типа, которые задаются идентификаторами CHAR, INTEGER и BOOLEAN. Дополнительно к предопределенным порядковым типам, в Паскале предусмотрено два метода для программиста для определения новых порядковых типов, а именно:
- Перечислимые типы, значениями которых являются уникальные идентификаторы.
- Типы диапазон, значениями которых являются последовательные значения другого порядкового типа.
То есть новый порядковые типы данных могут быть определены перечислением констант типа или указанием, что значения типа являются поддиапазоном значений существующего типа. Синтаксис для обозначения таких порядковых типов следующий:
<обозначение типа> ::= <идентификатор типа> | <новый тип>
<идентификатор типа> ::= <идентификатор>
<новый тип> ::= <перечислимый тип> | <тип диапазон>
Способы описания для <перечислимый тип> и <тип диапазон> будут даны в соответствующих разделах ниже.
Когда определяется новый тип, ему может быть дано имя в объявлении типов. Это объявление должно предшествовать объявлению переменных блока.
<блок> ::= <раздел объявлений типов> <раздел объявлений переменных>
<раздел объявлений процедур> <раздел операторов>
<раздел объявлений типов> ::= TYPE <объявления типов> |
Это правило показывает что <раздел объявлений типов> может быть пустым (как это было во всех программах до данного места)
<объявления типов> ::= <объявления типов> <объявление типа> | <объявление типа>
<объявление типа> ::=<идентификатор > = <обозначение типа>
Контекстное правило, которое сопровождает эти синтаксические правила, говорит о том, что только некоторые идентификаторы являются <объявлением типа>:
CR Чтобы быть использованным как <идентификатор типа>, <идентификатор> должен ранее появиться в <объявлениях типов>.
Таким образом для
и T1 и T2 являются идентификаторами типа и могут быть использованы в текущем блоке для объявления переменных и формальных параметров, как ранее использовался CHAR.
