Extended тип данных. Целочисленные типы данных
Понятие типа является одним из фундаментальных понятий любого языка программирования. Объекты (константы , переменные , функции, выражения), которыми оперирует программа, относятся к определенному типу.
Тип - это множество значений, которые могут принимать объекты программы, и совокупность операций, допустимых над этими значениями .
Например , значения 1 и 2 относятся к целочисленному типу , их можно складывать, умножать и выполнять другие арифметические операции . Значения «монитор» и «Паскаль» носят лингвистический характер, они имеют свой набор допустимых операций. В большинстве широкоупотребительных языков могут использоваться только строго определенные, заранее известные типы. Pascal , наряду со стандартными типами, имеющимися в других языках высокого уровня, позволяет программисту образовывать собственные типы.
Все допустимые в языке Паскаль типы подразделяются на две большие группы: простые и сложные (структурированные).
| Тип | Диапазон | Мантисса, знаков | Требуемая память (байт) |
| REAL | 2.9*10Е-39..1.7*10Е38 | 11-12 | |
| SINGLE | 1.5*10Е-45..3.4*10Е38 | 7-8 | |
| DOUBLE | 5.0*10Е-324..1.7*10Е308 | 15-16 | |
| EXTENDED | 1.9*10Е-4951..1.1*10Е4932 | 19-20 | |
| COMP | -2Е+63+1..2Е+63-1 | 10-20 |
Эффективное использование типов SINGLE, DOUBLE, EXTEND, COMP возможно только при включенной директиве {$N+}. По умолчанию она находится в выключенном состоянии. Для решения инженерно-экономических задач достаточно значений типа REAL.
Пример
Var Res, Summa, Itog: real;
Булевский тип данных описывается идентификатором BOOLEAN. Переменные и константы этого типа могут принимать только одно из двух значений: TRUE (истина) или FALSE (ложь).
Пример
Var Sel1, Sel2: boolean;
A,B,C,D: boolean;
Выражения булевского типа занимают в памяти 1 байт и используются в логических выражениях и выражениях отношения, а также для управления порядком выполнения операторов программы.
Литерный (символьный) тип описывается стандартным идентификатором CHAR. Константы и переменные этого типа могут принимать одно из значений кодовой таблицы ASCII. Значение константы или переменной этого типа заключается в апострофы.
Например , Var Bukva, Znak, Simvol: char;
Bukva:=’A’; Znak:=’+’; Simvol:=’!’
Переменные символьного типа занимают в памяти 1 байт. Использование данных типа char в арифметических выражениях запрещено. К литерным значениям могут применяться операции сравнения, результат при этом зависит от номера литерной переменной или константы в кодовой таблице.
Кроме стандартных типов данных, Паскаль поддерживает скалярные типы, определенные пользователем . К ним относятся перечисляемый и интервальный типы . Данные этих типов занимают в памяти 1 байт, поэтому любой пользовательский тип не может содержать более 255 элементов. Их применение значительно улучшает наглядность программы, делает более легким поиск ошибок и экономит память.
Перечисляемый тип задается непосредственно перечислением всех значений, которые может принимать переменная данного типа. Отдельные значения указываются через запятую, а весь список заключается в круглые скобки.
Формат
Type <имя типа>=(<значение1, значение2, ..., значениеN>);
Var <идентификатор, ...>: < имя типа>;
Пример
Type Season =(Spring, Summer, Autumn, Winter);
Var S1, S2: Season;
Autumn: (September, October, Nowember);
В данном примере приведен явно описанный тип данных пользователя Season. Определены их значения - обозначения времен года. Переменные S1 и S2 могут принимать только одно из перечисленных значений. Попытка присвоить им любое другое значение вызовет программное прерывание . Третий тип перечисления - анонимный (не имеет имени) и задается перечислением значений в разделе Var. Autumn является переменной этого типа и может принимать значения September, October, Nowember. Таким образом, может быть задан любой тип, но это не всегда приемлемо. Первый способ, безусловно, более понятен и больше соответствует характеру языка Pascal.
Интервальный тип позволяет задавать две константы, определяющие границы диапазона значений для данной переменной. Компилятор при каждой операции с переменной интервального типа генерирует подпрограммы проверки, определяющие, остается ли значение переменной внутри установленного для нее диапазона. Обе константы должны принадлежать одному из стандартных типов, кроме вещественного. Значение первой константы должно быть обязательно меньше значения второй.
Формат
Type <имя типа> = <константа1> .. <константа2>;
Var <идентификатор>: < имя типа>;
Пример
Type Days = 1.. 31;
Var Work_d, Free_d: Days;
В этом примере переменные Work_d, Free_d имеют тип Days и могут принимать любые значения из диапазона 1 . . 31.
Выход из диапазона вызывает программное прерывание.
Можно определить интервальный тип, задав границы диапазона не значениями констант, а их именами:
Const Min = 1; Max = 31;
Type Days = Min .. Max;
Var Work_d, Free_d: Days;
Структурированные типы данных базируются на скалярных типах и могут содержать их различные комбинации. Они определяют упорядоченную совокупность скалярных элементов и характеризуются типом своих компонентов . В языке Паскаль представлены следующие структурированные типы данных:
строка - последовательность символов, заключенная в апострофы;
массив - структурированный тип данных, состоящий из фиксированного количества элементов одного и того же типа, доступ к которым осуществляется по индексу;
множество - набор выбранных по какому-либо признаку или группе признаков объектов, которые можно рассматривать как единое целое;
запись - совокупность фиксированного числа компонентов разного типа;
файл - последовательность компонентов одного типа и одной длины.
Еще двум структурированным типам - процедурному и типу object (объектному) - трудно поставить в соответствие данные в обычном представлении.
Рисунок 1 - Набор основных типов языка Паскаль
Любая программа, написанная на любом языке программирования, по большому счету предназначена для обработки данных. В качестве данных могут выступать числа, тексты, графика, звук и др. Одни данные являются исходными, другие – результатом, который получается путем обработки исходных данных программой.
Данные хранятся в памяти компьютера. Программа обращается к ним с помощью имен переменных, связанных с участками памяти, где хранятся данные.
Переменные описываются до основного кода программы. Здесь указываются имена переменных и тип хранимых в них данных.
В языке программирования Паскаль достаточно много типов данных. Кроме того, сам пользователь может определять свои типы.
Тип переменной определяет, какие данные можно хранить в связанной с ней ячейке памяти.
Переменные типа integer могут быть связаны только с целыми значениями обычно в диапазоне от -32768 до 32767. В Pascal есть другие целочисленные типы (byte, longint).
Переменные типа real хранят вещественные (дробные) числа.
Переменная булевского (логического) типа (boolean) может принимать только два значения - true (1, правда) или false (0, ложь).
Символьный тип (char) может принимать значения из определенной упорядоченной последовательности символов.
Интервальный тип определяется пользователем и формируется только из порядковых типов. Представляет собой подмножество значений в конкретном диапазоне.
Можно создать собственный тип данных простым перечислением значений, которые может принимать переменная данного типа. Это так называемый перечисляемый тип данных .
Все вышеописанное – это простые типы данных. Но бывают и сложные, структурированные, которые базируются на простых типах.
Массив – это структура, занимающая в памяти единую область и состоящая из фиксированного числа компонентов одного типа.
Строки представляет собой последовательность символов. Причем количество этих символов не может быть больше 255 включительно. Такое ограничение является характерной чертой Pascal.
Запись – это структура, состоящая из фиксированного числа компонент, называемых полями. В разных полях записи данные могут иметь разный тип.
Множества представляют собой совокупность любого числа элементов, но одного и того же перечисляемого типа.
Файлы для Pascal представляют собой последовательности однотипных данных, которые хранятся на устройствах внешней памяти (например, жестком диске).
Понятие такого типа данных как указатель связано с динамическим хранением данных в памяти компьютера. Часто использование динамических типов данных является более эффективным в программировании, чем статических.
Типы данных языка Паскаль
Любые данные (константы, переменные, значения функций или выражения) в Турбо Паскале характеризуются своими типами. Тип определяет множество допустимых значений, которые может иметь тот или иной объект, а также множество допустимых операций, которые применимы к нему. Тип также определяет формат внутреннего представления данных в памяти компьютера.
Существуют следующие типы данных в Турбо-Паскале.
1) Простые типы:
– вещественные;
– символьные;
– булевские (логические);
– перечисляемые;
– ограниченные (диапазонные).
2) Составные (структурированные) типы:
– регулярные (массивы);
– комбинированные (записи);
– файловые;
– множественные;
– строковые;
– объекты.
3) Ссылочные типы (типизированные и нетипизированные указатели).
4) Процедурные типы.
В Турбо Паскале предусмотрен механизм создания новых типов данных, благодаря чему общее количество типов, используемых в программе может быть сколь угодно большим.
Целый тип . Значениями целого типа являются элементы подмножества целых чисел. В Турбо-Паскале существует пять целых типов. Их названия, диапазон значений, длина представления в байтах приведены в табл. 6.
Таблица 6
Целые типы данных
Целые переменные описываются с использованием указанных выше зарезервированных слов:
i, j, k: integer;
Данные целого типа хранятся в памяти точно. Например, переменные типа integer занимают в памяти 2 байта (16 бит), которые распределяются следующим образом: 1 бит отводится для хранения знака числа (0, если число положительное, и 1, если число отрицательное) и 15 бит для хранения числа в двоичной системе счисления. Максимальное десятичное число, которое можно записать как двоичное в 15 бит – это 32767.
При использовании процедур и функций с целочисленными параметрами следует руководствоваться «вложенностью» типов, т.е. везде где используется word, допускается использование byte (но не наоборот), в longint «входит» integer, который, в свою очередь, включает в себя shortint.
Для целого типа определены пять основных операций, результатом которых также является целое число: +, -,*, div, mod (сложение, вычитание, умножение, целочисленное деление и остаток от целочисленного деления). В арифметических выражениях операции *, div, mod имеют более высокий приоритет по сравнению с операциями +, -. Примеры записи выражений:
Перечень процедур и функций, применимых к целочисленным типам, приведен в табл. 7. Буквами b, s, w, i, l обозначены выражения соответственно типа byte, shortint, word, integer, и longint; x – выражение любого из этих типов; идентификаторы vb, vs, vw, vi, vl, vx обозначают переменные соответствующих типов. В квадратных скобках указывается необязательный параметр.
Таблица 7
Стандартные процедуры и функции, применимые к целым типам
| Обращение | Тип результата | Действие |
| Abs (x) | x | Возвращает модуль x |
| Chr (b) | Char | Возвращает символ по его коду |
| Dec (vx [, i]) | - | Уменьшает значение vx на i, а при отсутствии i – на 1 |
| Inc (vx [, i]) | - | Увеличивает значение vx на i, а при отсутствии i – на 1 |
| Hi (i) | Byte | Возвращает старший байт аргумента |
| Hi (i) | Byte | То же |
| Lo (i) | Byte | Возвращает младший байт аргумента |
| Lo (w) | Byte | То же |
| Odd (l) | Byte | Возвращает true, если аргумент – нечетное число |
| Random (w) | Как у параметра | Возвращает псевдослучайное число, равномерно распределенное в диапазоне 0…(w-1) |
| Sqr (x) | x | Возвращает квадрат аргумента |
| Swap (i) | Integer | |
| Swap (w) | Word | Меняет местами байты в слове |
| Succ(x) | Как у параметра | Возвращает следующее целое значение, т.е. x+1 |
| Pred(x) | Как у параметра | Возвращает предшествующее целое значение, т.е. x-1 |
При действиях с целыми числами тип результата будет соответствовать типу операнда, а если операнды относятся к различным целым типам, - типу того операнда, который имеет максимальный диапазон значений. Возможное переполнение результата не контролируется, что может привести к ошибкам в программе.
Вещественный тип. Значения вещественных типов определяют произвольное число с некоторой конечной точностью, зависящей от внутреннего формата вещественного числа. В Турбо-Паскале существуют пять вещественных типов (табл. 8).
Таблица 8
Вещественные типы данных
Вещественные переменные описываются с использованием указанных выше зарезервированных слов:
Вещественное число в памяти компьютера состоит из 3-х частей:
Знаковый разряд числа;
Экспоненциальная часть;
Мантисса числа.
Мантисса имеет длину от 23 (Single) до 63 (Extended) двоичных разрядов, что и обеспечивает точность 7-8 для Single и 19-20 для Extended десятичных цифр. Десятичная точка (запятая) подразумевается перед левым (старшим) разрядом мантиссы, но при действиях с числом ее положение сдвигается влево или вправо в соответствии с двоичным порядком числа, хранящимся в экспоненциальной части, поэтому действия над вещественными числами называют арифметикой с плавающей точкой (запятой).
Доступ к типам Single, Double и Extended осуществляется только при особых режимах компиляции. Для включения данных режимов следует выбрать пункт меню Options , Compiler… и включить опцию 8087/80287 в группе Numeric processing .
Особое положение в Турбо Паскаль занимает тип Comp, который трактуется как вещественное число без экспоненциальной и дробной частей. Фактически, Comp – Это большое целое число со знаком, сохраняющее 19…20 значащих десятичных цифр. В то же время в выражениях Comp полностью совместим с любыми другими вещественными типами: над ним определены все вещественные операции, он может использоваться как аргумент математических операций и т.д.
Вещественные числа задаются в десятичной системе счисления в одной из двух форм .
В форме с фиксированной точкой запись состоит из целой и дробной частей, отделенных друг от друга точкой, например:
0.087 4.0 23.5 0.6
В форме с плавающей точкой запись содержит букву Е, которая означает «умножить на десять в степени», причем степень является целым числом, например:
7Е3 6.9Е-8 0.98Е-02 45Е+04
Над объектами вещественного типа определены следующие операции: +, -, *, /.
Операции «*» и «/» имеют более высокий приоритет по сравнению с операциями «+» и «-».
Если хотя бы один операнд вещественный, то операции +, -, *, / приводят к вещественному результату. Операция деления / приводит к вещественному результату и в случае двух целых операндов, например: 9/3 = 3.0.
Для работы с вещественными данными могут использоваться стандартные математические функции, представленные в табл. 9. Результат работы этих функций также является вещественным.
Таблица 9
Математические функции, работающие с вещественными данными
Переменные и константы типа REAL запрещается использовать:
– в функциях pred(x), succ(x), ord(x);
– в качестве индексов массивов;
– в качестве меток в операторах передачи управления;
– в качестве управляющих переменных (параметров цикла).
Для перевода вещественного числа в целое можно воспользоваться функциями:
trunc(x) – целая часть х (х – вещественное);
round(x) – округление до ближайшего целого (х- вещественное).
Символьный тип. Символьные переменные описываются с помощью зарезервированного слова char:
Значения этого типа выбираются из упорядоченного множества символов (из множества ASCII), состоящего из 256 символов. Каждому символу приписывается целое число из диапазона 0..255. Например, прописные буквы латинского алфавита A..Z имеют коды 65..90, а строчные буквы – коды 97..122.
Значением переменной символьного типа является один символ, заключенный в апострофы, например:
‘F’ ‘8’ ‘*’
Символьные переменные можно сравнивать между собой, при этом сравниваются коды символов.
Существуют функции, которые устанавливают соответствие между символом и его кодом:
ord(с) – выдает номер символа с;
chr(i) – выдает символ с номером i.
Эти функции являются обратными по отношению друг к другу.
Логический тип . Логические переменные описываются с помощью зарезервированного слова boolean:
p1, p2: boolean;
Переменные логического типа принимают два значения: true (истина), false (ложь).
Эти величины упорядочены следующим образом: false < true. false имеет порядковый номер 0, true имеет порядковый номер 1.
Переменным логического типа можно либо присвоить значение непосредственно, либо использовать логическое выражение. Например,
a, d, g, b: boolean;
Операции отношения (<, <=, >, >=, =, <>), применяемые к целым, вещественным и символьным переменным, дают логический результат.
Логические операции над операндами логического типа также дают логический результат (операции приведены в порядке убывания приоритета) (подробнее см. табл. 3 и 5):
not – отрицание (операция НЕ);
and – логическое умножение (операция И);
or – логическое сложение (операция ИЛИ);
xor – исключающее ИЛИ.
Выражение (not a) имеет значение, противоположное значению а.
Выражение (a and b) дает значение true, если только и а и b имеют значение true, в остальных случаях значение этого выражения есть false.
Выражение (a or b) дает значение false, если только и а и b имеют значение false, во всех остальных случаях результат true.
Перечисляемый тип . Нестандартный перечисляемый тип задается перечислением в виде имен значений, которые может принимать переменная. Каждое значение именуется некоторым идентификатором и располагается в списке, обрамленном круглыми скобками. Общий вид описания перечисляемого типа:
x = (w1, w2, …, wn);
где х – имя типа, w1, w2,…, wn – значения, которые может принимать переменная типа х.
Эти значения являются упорядоченными w1 К аргументу w перечисляемого типа применимы следующие стандартные функции: succ(w), pred(w), ord(w). color=(red, black, yellow, green) ww=(left, up, right, down); f: array of ww; succ(d) = yellow; Переменные а и в имеют тип w. они могут принимать одно из трех значений, причем on К величинам перечисляемого типа применимы операции отношения: =, <>, <=, >=, <, >. Допускается указывать константы перечисляемого типа непосредственно в разделе var
без использования раздела type
, например c,d: (red, black, yellow, green); Диапазонный (ограниченный) тип
. При определении ограниченного типа указывают начальное и конечное значения, которые может принимать переменная диапазонного типа. Значения разделяют двумя точками. Описание ограниченного типа имеет вид Здесь а – имя типа, min, max – константы. При задании ограниченного типа должны выполняться следующие правила: – обе граничные константы min и max должны быть одинакового типа; – ограниченный тип создается из данных базового типа, в качестве которого можно выбрать целый, символьный или перечисляемый типы. Например: col = red.. yellow; letter = ‘a’..’f’; – переменные ограниченного типа можно описать в разделе var, не обращаясь к разделу type: – ограниченный тип наследует все свойства базового типа, из которого он создается; – граница min всегда должна быть меньше границы max. Массивы
. Массив – это сложный тип, представляющий собой структуру, состоящую из фиксированного числа компонент одного типа. Тип компонента называется базовым типом. Все компоненты массива можно легко упорядочить и обеспечить доступ к любому из них простым указанием его порядкового номера. Описание массива в разделе var
имеет вид: a: array
of
t2; где а – имя массива, array
, of
– служебные слова (означают «массив из…»), t1 – тип индексов; t2 – тип компонент (базовый тип). Количество индексов определяет размерность массива. Индексы могут быть целого (кроме longint), символьного, логического, перечисляемого и диапазонного типов. Индексы разделяются запятыми и заключаются в квадратные скобки. Компоненты массива могут быть любого типа, кроме файлового. Пример 1.
Рассмотрим одномерный массив С, значениями которого являются пять вещественных чисел: 4.6 6.23 12 -4.8 0.7 Описание этого массива выглядит следующим образом: c: array of real; По конкретному значению индекса можно выбрать определенную компоненту массива (например, C означает третий элемент массива С, т.е. число 12). Пример 2.
Рассмотрим двумерный массив В (матрицу В), значением которого является таблица из целых чисел: Описание данного массива выглядит следующим образом: b of integer; Здесь b – имя массива, первый индекс является номером строки и принимает значения от 1 до 2, второй – номер столбца и принимает значения от 1 до 4. По конкретным значениям индексов можно выбрать определенную компоненту массива (например, b означает элемент таблицы, стоящий в первой строке и третьем столбце, т.е. число -4). Индексы могут быть произвольными выражениями, соответствующими типу индексов из описания массива: a: array of real; a[(i+1)*2] := 24; Набор операций над элементами массива полностью определяется типом этих элементов. Строковый тип
. Строковый тип – множество символьных цепочек произвольной длины (от нуля до заданного числа). Переменные строкового типа описываются с помощью служебного слова string
: b: string
; Особенности: – значение строковой переменной может быть введено с помощью клавиатуры, присвоено в операторе присваивания, прочитано из файла. При этом длина введенной строки может быть любой (меньше указанного размера, равна размеру или больше, в последнем случае, лишние символы отбрасываются); a:= ‘Результаты’; – допускается использовать операцию конкатенации в операторе присваивания, так как строки могут динамически изменять свою длину: а:= a + ‘ вычислений’; – максимальная длина строковой переменной 255 символов, это указание длины может быть опущено: a: string
; a1: string
; Переменные а и а1 – одинаковы (эквивалентное описание). – память под переменные строкового типа отводится по максимуму, но используется лишь часть памяти, реально занятая символами строки в данный момент. Для описания строковой переменной длины n используется n+1 байт памяти: n байтов - для хранения символов строки, n+1 –й байт – для хранения текущей длины. – над значениями строковых типов определены операции сравнения: < <= > >= = <>. Короткая строка всегда меньше длинной. Если строки имеют одинаковую длину, то сравниваются коды символов. – возможен доступ к отдельным элементам строки аналогично доступу к элементам массива: а, a. В квадратных скобках указывается номер элемента строки. Процедуры и функции, ориентированные на работу со строками. concat (s1, s2,…)
– функция слияния строк, s1, s2,
…- строки, число строк может быть произвольным. Результатом работы функции является строка. Если длина результирующей строки больше 255 символов, то строка усекается до 255 символов. copy (s, index, count)
– функция выделения строки из исходной строки s
длиной count
символов, начиная с символа под номером index
. delete (s, index, count)
– процедура удаления из строки s подстроки длиной count
символов, начиная с символа с номером index
. insert (s1, s2, index)
– процедура вставки строки s1
в строку s2
, начиная с символа с номером index
. length(s)
– функция определения текущей длины строки, возвращает число равное текущей длине строки. pos(s1, s2)
– функция поиска в строке s2
подстроки s1
. выдает номер позиции первого символа подстроки s1
в строке s2
(или 0, если этой строки нет). val (st, x, code)
– процедура преобразования строки s в целую или вещественную переменную x
. Параметр code
содержит 0, если преобразование прошло успешно (и в x
помещается результат преобразования), или номер позиции строки, где обнаружен ошибочный символ (в таком случае значение x
не меняется). Совместимость и преобразование типов
. Турбо Паскаль – это типизированный язык. Он построен на основе строго соблюдения концепции типов, в соответствии с которой все применяемые в языке операции определены только над операндами совместимых типов. Два типа считаются совместимыми, если: – оба они есть один и тот же тип; – оба вещественные; – оба целые; – один тип есть тип-диапазон второго типа; – оба являются типами диапазонами одного и того же базового типа; – оба являются множествами, составленными из элементов одного и того же базового типа; – оба являются упакованными строками (определены с предшествующим словом packed) одинаковой максимальной длины; – один есть тип-строка, а другой – тип-строка или символ; – один тип есть любой указатель, а другой – указатель на родственный ему объект; – оба есть процедурные типы с одинаковым типом результата (для типа-функции), количеством параметров и типом взаимно соответствующих параметров. Совместимость типов приобретает особое значение в операторах присваивания. Пусть t1 – тип переменной, а t2 – тип выражения, то есть выполняется присваивание t1:=t2. Это присваивание возможно в следующих случаях: – t1 и t2 есть один и тот же тип, и этот тип не относится к файлам, массивам файлов, записям, содержащим поля-файлы, или массивам таких записей; – t1 и t2 являются совместимыми порядковыми типами, и значение t2 лежит в диапазоне возможных значений t1; – t1 и t2 являются вещественными типами, и значение t2 лежит в диапазоне возможных значений t1; – t1 – вещественный тип и t2 – целый тип; – t1 – строка и t2 – символ; – t1 – строка и t2 – упакованная строка; – t1 и t2 – совместимые упакованные строки; – t1 и t2 – совместимые множества и все члены t2 принадлежат множеству возможных значений t1; – t1 и t2 – совместимые указатели; – t1 и t2 – совместимые процедурные типы; – t1 – объект и t2 – его потомок. В программе данные одного типа могут преобразовываться в данные другого типа. Такое преобразование может быть явным или неявным. При явном преобразовании типов вызываются специальные функции преобразования, аргументы которых принадлежат одному типу, а значения – другому. Пример – уже рассмотренные функции ord, trunc, round, chr. Неявное преобразование возможно только в двух случаях: – в выражениях, составленных из вещественных и целочисленных переменных, последние автоматически преобразуются к вещественному типу, и все выражение в целом приобретает вещественный тип; – одна и та же область памяти попеременно трактуется как содержащая данные то одного, то другого типа (совмещение в памяти данных разного типа). ЛЕКЦИЯ 2
Основы
программирования.
Введение в Pascal.
Типы данных. Операции. Алфавит языка
Pascal
Любой естественный
язык состоит из таких элементов, как
символы, слова, словосочетания,
предложения. В языке программирования
также есть аналогичные элементы: символы,
слова, выражения (словосочетания),
операторы (предложения). Слова образуются
из совокупности символов. Выражения
-
это группы
слов, а операторы -
это комбинации
слов и выражений. Символы языка - есть
элементарные знаки (буквы), которые
используются для составления каких-то
текстов. Так вот, набор этих символов и
образует алфавит языка. Алфавит языка
Pascal
состоит из: 1.прописных и
строчных букв латинского алфавита, в
который входят следующие символы: A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
- прописные буквы; A
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
- строчные буквы; 2. десятичные
арабские цифры: 0 1 2 3 4 5 6 7 8 9; 3. шестнадцатеричные
цифры (строятся из десятичных цифр и
букв от A до F); 4. 32 прописные и
строчные буквы русского алфавита; 5. специальные
символы: Комбинации
специальных символов могут образовывать
составные символы: : = присваивание; < > не равно; >= больше или
равно; <= меньше или
равно; Диапазон значений; (* *) или { }-
комментарий. Структура
Pascal-программы
Для того чтобы
Pasсal-компилятор правильно понял, какие
именно действия от него ожидаются, ваша
программа должна быть оформлена в полном
соответствии с синтаксисом (правилами
построения программ) этого языка. Любая Pascal-программа
может состоять из следующих блоков
(квадратными скобками здесь и далее
помечены необязательные части): program <имя_программы>; [ uses
<имена_подключаемых_модулей>;] [ label <список_меток>;] [ const <имя_константы>
= <значение_константы>;] [ type <имя_типа>
= <определение_типа>;] [ var <имя_переменной>
: <тип_переменной>;] [ procedure <имя_процедуры>
<описание_процедуры>;] [ function <имя_функции>
<описание_функции>;] begin {начало
основного тела программы} <операторы> end. (* конец
основного тела программы *) Поздние версии
компиляторов языка Pascal уже не требуют
указывать название программы, то есть
строку program <имя_программы>; можно
опустить. Но это возможно только в том
случае, если вся программа содержится
в одном модуле-файле. Если же программа
состоит из нескольких самостоятельных
кусков - модулей, то каждый из них должен
иметь заголовок (program или unit). Любой из перечисленных
необязательных разделов может встречаться
в тексте программы более одного раза,
их общая последовательность также может
меняться, но при этом всегда должно
выполняться главное правило языка
Pascal: прежде чем объект будет использован,
он должен быть объявлен и описан. Компиляторы языка
Pascal не различают строчные и прописные
буквы, а пробельные символы игнорируют,
поэтому текст программы можно
структурировать так, чтобы читать и
отлаживать его было наиболее удобно. Директивы
компилятора
Строка,
начинающаяся символами {$, является не
комментарием, а директивой компилятора
- специальной командой, от которой
зависит процесс компиляции и выполнения
программы. Директивы мы будем рассматривать
в тех разделах, к которым они относятся
"по смыслу". Например,
строка {$I-,Q+}
отключает контроль правильности
ввода-вывода, но включает контроль
переполнения при вычислениях. Идентификаторы
Имена, даваемые
программным объектам (константам, типам,
переменным, функциям и процедурам, да
и всей программе целиком) называются
идентификаторами. Они могут состоять
только из цифр, латинских букв и знака
"_" (подчеркивание). Однако цифра
не может начинать имя. Идентификаторы
могут иметь любую длину, но если у двух
имен первые 63 символа совпадают, то
такие имена считаются идентичными. Вы можете давать
программным объектам любые имена, но
необходимо, чтобы они отличались от
зарезервированных слов, используемых
языком Pascal,
потому что компилятор все равно не
примет переменные с "чужими"
именами. Приведем список
наиболее часто встречающихся
зарезервированных слов: array implementation shl case interface string const label then file pointer uses far procedure var for program while forward record with function repeat xor Переменные и
типы данных
Переменная - это
программный объект, значение которого
может изменяться в процессе работы
программы. Тип данных - это
характеристика диапазона значений,
которые могут принимать переменные,
относящиеся к этому типу данных. Все используемые
в программе переменные должны быть
описаны в специальном разделе var
по следующему шаблону: var
<имя_переменной_1> [, <имя_переменной_2,
_>] : <имя_типа_1>; <имя_переменной_3>
[, <имя_переменной_4, _>] : <имя_типа_2>; Язык Pascal
обладает большим набором разнообразных
типов данных, однако сейчас мы укажем
лишь некоторые из них. Обо всех же типах
данных мы поговорим далее. Константы
Константа - это
объект, значение которого известно еще
до начала работы программы. Константы необходимы
для оформления наглядных программ,
незаменимы при использовании в тексте
программы многократно повторяемых
значений, удобны в случае необходимости
изменения этих значений сразу во всей
программе. В языке Pascal
существует три вида констант: Неименованные
константы (цифры и числа, символы и
строки, множества); Именованные
нетипизированные константы; Именованные
типизированные константы. Неименованные
константы
Неименованные
константы не имеют имен, и потому их не
нужно описывать. Тип неименованной
константы определяется автоматически,
по умолчанию: Любая
последовательность цифр (возможно,
предваряемая знаком "-" или "+"
или разбиваемая одной точкой) воспринимается
компилятором как неименованная константа
- число (целое или вещественное); Любая
последовательность символов, заключенная
в апострофы, воспринимается как
неименованная константа - строка; Любая
последовательность целых чисел либо
символов через запятую, обрамленная
квадратными скобками, воспринимается
как неименованная константа - множество. Кроме того,
существуют две специальные константы
true
и false,
относящиеся к логическому типу данных. Примерами
использования неименованных констант
могут послужить следующие операторы: real2:= 12.075 + х; string4:=
"abc" + string44; set5:= * set55; boolean6:= true; Нетипизированные
константы
Именованные
константы, как следует из их названия,
должны иметь имя. Стало быть, эти имена
необходимо сообщить компилятору, то
есть описать в специальном разделе
const. Если не указывать
тип константы, то по ее внешнему виду
компилятор сам определит, к какому
(базовому) типу ее отнести. Любую уже
описанную константу можно использовать
при объявлении других констант, переменных
и типов данных. Вот несколько примеров
описания нетипизированных именованных
констант: Типизированные
константы
Типизированные
именованные константы представляют
собой переменные(!) с начальным значением,
которое к моменту старта программы уже
известно. Следовательно, во-первых,
типизированные константы нельзя
использовать для определения других
констант, типов данных и переменных, а
во-вторых, их значения можно изменять
в процессе работы программы. Описание
типизированных констант производится
по следующему шаблону: const
<имя_константы> : <тип_константы>
= <начальное_значение>; Из приведенных
ниже примеров видно, как это сделать: const n: integer = -10; b: boolean = true; Примеры типизированных
констант других типов мы будем приводить
по мере изучения соответствующих типов
данных. Типы данных языка
Pascal
Компиляторы языка
Pascal требуют, чтобы сведения об объеме
памяти, необходимой для работы программы,
были предоставлены до начала ее работы.
Для этого в разделе описания переменных
(var) нужно перечислить все переменные,
используемые в программе. Кроме того,
необходимо также сообщить компилятору,
сколько памяти каждая из этих переменных
будет занимать. Все это можно
сообщить программе, просто указав тип
будущей переменной. Имея информацию о
типе переменной, компилятор "понимает",
сколько байт необходимо отвести под
нее, какие действия с ней можно производить
и в каких конструкциях она может
участвовать. Для удобства
программистов в языке Pascal существует
множество стандартных типов данных и
плюс к тому возможность создавать новые
типы данных на основе уже имеющихся
(стандартных или опять-таки определенных
самим программистом), которые называются
конструируемые. Разделение на
базовые и конструируемые типы данных
в языке Pascal показано в таблице: Порядковые(дискретные)
типы данных
Адресные
типы данных
Структурированные
типы данных
Арифметические
типы данных
Базовые
типы данных
Логический Символьный Вещественные Нетипизи рованный указатель Конструируемые
типы
Перечисляемый week = (su, mo, tu, we, th,
fr,sa); Типизированный указатель Массив array Строка string Запись record Процедурный Объектный Интервал (диапазон) Типы данных, конструируемые программистом Порядковые
типы данных
Среди базовых
типов данных особо выделяются порядковые
типы. Такое название можно обосновать
двояко: 1. Каждому элементу
порядкового типа может быть сопоставлен
уникальный (порядковый) номер. Нумерация
значений начинается с нуля. Исключение
- типы данных shortint, integer и longint. Их нумерация
совпадает со значениями элементов. 2.Кроме того, на
элементах любого порядкового типа
определен порядок (в математическом
смысле этого слова), который напрямую
зависит от нумерации. Таким образом,
для любых двух элементов порядкового
типа можно точно сказать, который из
них меньше, а который - больше. Стандартные
подпрограммы, обрабатывающие порядковые
типы данных
Только для величин
порядковых типов определены следующие
функции и процедуры: 1.Функция ord(x)
возвращает порядковый номер значения
переменной x (относительно того типа, к
которому принадлежит переменная х). 2.Функция pred(x)
возвращает значение, предшествующее х
(к первому элементу типа неприменима). 3.Функция succ(x)
возвращает значение, следующее за х (к
последнему элементу типа неприменима). 4.Процедура inc(x)
возвращает значение, следующее за х
(для арифметических типов данных это
эквивалентно оператору x:=x+1). 5.Процедура inc(x,k)
возвращает k-е значение, следующее за х
(для арифметических типов данных это
эквивалентно оператору x:=x+k). 6.Процедура dec(x)
возвращает значение, предшествующее х
(для арифметических типов данных это
эквивалентно оператору x:=x-1). 7.Процедура dec(x,k)
возвращает k-e значение, предшествующее
х (для арифметических типов данных это
эквивалентно оператору x:=x-k). На
первый взгляд кажется, будто результат
применения процедуры inc(x) полностью
совпадает с результатом применения
функции succ(x). Однако разница между ними
проявляется на границах допустимого
диапазона. Функция succ(x) неприменима к
максимальному элементу типа, а вот
процедура inc(x) не выдаст никакой ошибки,
но, действуя по правилам машинного
сложения, прибавит очередную единицу
к номеру элемента. Номер, конечно же,
выйдет за пределы диапазона и за счет
усечения превратится в номер минимального
значения диапазона. Получается, что
процедуры inc() и dec() воспринимают любой
порядковый тип словно бы "замкнутым
в кольцо": сразу после последнего
вновь идет первое значение. Поясним
все сказанное на примере. Для типа данных type
sixteen = 0..15; попытка
прибавить 1 к числу 15 приведет к следующему
результату: Начальная
единица будет отсечена, и потому
получится, что inc(15)=0. Аналогичная
ситуация на нижней границе допустимого
диапазона произвольного порядкового
типа данных наблюдается для процедуры
dec(x) и функции pred(x): dec(min_element)=
max_element Типы данных,
относящиеся к порядковым
1. Логический тип
boolean имеет два значения: false и true, и для
них выполняются следующие равенства: ord(false)=0,
ord(true)=1, false pred(true)=false,
succ(false)=true, inc(true)=false,
inc(false)=true, dec(true)=false,
dec(false)=true. 2. В символьный тип
char входит 256 символов расширенной таблицы
ASCII (например, "a", "b", "я", "7", "#"). Номер
символа, возвращаемый функцией ord(),
совпадает с номером этого символа в
таблице ASCII. 3. Целочисленные
типы данных сведем в таблицу: Тип данных
Количество
байтов
Диапазон
2147483648..2147483647 4. Перечисляемые
типы данных задаются в разделе type явным
перечислением их элементов. Например: type week
=(sun,mon,tue,wed,thu,fri,sat) Напомним, что для
этого типа данных: inc(sat) = sun, dec(sun) =
sat. 5. Интервальные
типы данных задаются только границами
своего диапазона. Например: type month = 1..12; budni = mon..fri; 6. Типы данных,
конструируемые программистом, описываются
в разделе type по следующему шаблону: type <имя_типа> =
<описание_типа>; Например: type lat_bukvy =
"a".."z","A".."Z"; Базовые типы данных
являются стандартными, поэтому нет
нужды описывать их в разделе type. Однако
при желании это тоже можно сделать,
например, дав длинным определениям
короткие имена. Скажем, введя новый тип
данных type int = integer; можно немного
сократить текст программы. Вещественные
типы данных
Напомним, что эти
типы данных являются арифметическими,
но не порядковыми. Тип данных
Количество
байтов
Диапазон
(абсолютной величины)
1.5*10-45..3.4*1038 2.9*10-39..1.7*1038 5.0*10-324..1.7*10308 3.4*10-4932..1.1*104932 Конструируемые
типы данных
Эти типы данных
(вместе с определенными для них операциями)
мы будем рассматривать далее на протяжении
нескольких лекций. Операции и
выражения
Арифметические
операции
Поговорим об
операциях - стандартных действиях,
разрешенных для переменных того или
иного базового типа данных. Основу будут
составлять арифметические и логические
операции. Замечание: Все
перечисленные ниже операции (за
исключением унарных "-" и not) требуют двух
операндов. 1. Логические
операции (and – логическое И, or – логическое
ИЛИ, not – логическое НЕ, xor – исключающее
ИЛИ) применимы только к значениям типа
boolean. Их результатом также служат величины
типа boolean. Приведем таблицы значений
для этих операций: true
false true false false false true false false 2. Операции сравнения
(=, <>, >, <, <=, >=) применимы ко всем
базовым типам. Их результатами также
являются значения типа boolean. 3. Операции
целочисленной арифметики применимы
только к целым типам. Их результат -
целое число, тип которого зависит от
типов операндов. a div b - деление а на
b нацело (не нужно, наверное, напоминать,
что деление на 0 запрещено, поэтому в
таких случаях операция выдает ошибку).
Результат будет принадлежать к типу
данных, общему для тех типов, к которым
принадлежат операнды. Например,
(shortint div byte = integer). Пояснить
это можно так: integer - это минимальный
тип, подмножествами которого являются
одновременно и byte, и shortint. a mod b - взятие остатка
при делении а на b нацело. Тип результата,
как и в предыдущем случае, определяется
типами операндов, а 0 является запрещенным
значением для b. В отличие от математической
операции mod, результатом которой всегда
является неотрицательное число, знак
результата "программистской"
операции mod определяется знаком ее
первого операнда. Таким образом, если
в математике (-2 mod 5)=3, то у нас (-2 mod 5)= -2. a shl k - сдвиг значения
а на k битов влево (это эквивалентно
умножению значения переменной а на 2k).
Результат операции будет иметь тот же
тип, что и первый ее операнд (а). a shr k - сдвиг значения
а на k битов вправо (это эквивалентно
делению значения переменной а на 2k
нацело). Результат операции будет иметь
тот же тип, что и первый ее операнд (а). and,or,not,xor - операции
двоичной арифметики, работающие с битами
двоичного представления целых чисел,
по тем же правилам, что и соответствующие
им логические операции. 4. Операции общей
арифметики (+, -, *, /) применимы ко всем
арифметическим типам. Их результат
принадлежит к типу данных, общему для
обоих операндов (исключение составляет
только операция дробного деления /,
результат которой всегда относится к
вещественному типу данных). Другие операции
Существуют и другие
операции, специфичные для значений
некоторых стандартных типов данных
языка Pascal. Эти операции мы рассмотрим
в соответствующих разделах: #, in, +, *, : см.
лекцию 5 «Символы. Строки. Множества» @, ^ : см.
лекцию 7 «Адреса и указатели» Стандартные
арифметические функции
К арифметическим
операциям примыкают и стандартные
арифметические функции. Их список с
кратким описанием мы приводим в таблице. Функция
Описание
Тип аргумента
Тип
результата
Абсолютное
значение (модуль) числа Арифметический Совпадает
с типом аргумента Арктангенс
(в радианах) Арифметический Вещественный Косинус (в
радианах) Арифметический Вещественный Экспонента
(ex) Арифметический Вещественный Взятие
дробной части числа Арифметический Вещественный Взятие целой
части числа Арифметический Вещественный Натуральный
логарифм (по основанию e) Арифметический Вещественный Проверка
нечетности числа Значение
числа Вещественный Округление
к ближайшему целому Арифметический Округление
"вниз" - к ближайшему меньшему
целому Арифметический Синус (в
радианах) Арифметический Вещественный Возведение
в квадрат Арифметический Вещественный Извлечение
квадратного корня Арифметический Вещественный Арифметические
выражения
Все арифметические
операции можно сочетать друг с другом
- конечно, с учетом допустимых для их
операндов типов данных. В роли операндов
любой операции могут выступать переменные,
константы, вызовы функций или выражения,
построенные на основе других операций.
Все вместе и называется выражением. Примеры арифметических
выражений: (x<0) and (y>0) -
выражение, результат которого принадлежит
к типу boolean; z shl abs(k) - вторым
операндом является вызов стандартной
функции; (x mod k) + min(a,b) +
trunc(z) - сочетание арифметических операций
и вызовов функций; odd(round(x/abs(x))) -
"многоэтажное" выражение. Порядок
вычислений
Если в выражении
расставлены скобки, то вычисления
производятся в порядке: чем меньше
глубина вложенности скобок, тем позже
вычисляется заключенная в них операция.
Если же скобок нет, то сначала вычисляются
значения операций с более высоким
приоритетом, затем - с менее высоким.
Несколько подряд идущих операций одного
приоритета вычисляются в последовательности
"слева направо". Таблица 2.1. Приоритеты
(для всех) операций языка Pascal Федеральное агентство по образованию Реферат
«ТИПЫ ДАННЫХ В ПАСКАЛЕ»
1. Типы данных
Любые данные, т.е. константы, переменные, свойства, значения функций или выражения характеризуются своими типами. Тип определяет множество допустимых значений, которые может иметь тот или иной объект, а также множество допустимых операций, которые применимы к нему. Кроме того, тип определяет также и формат внутреннего представления данных в памяти ПК. Вообще язык Object Pascal характеризуется разветвленной структурой типов данных (рис. 1.1). В языке предусмотрен механизм создания новых типов, благодаря чему общее количество используемых в программе типов может быть сколь угодно большим. Обрабатываемые в программе данные подразделяются на переменные, константы и литералы: Константы
представляют собой данные, значения которых установлены в разделе объявления констант и не изменяются в процессе выполнения программы. Переменные
объявляются в разделе объявления переменных, но в отличие от констант получают свои значения уже в процессе выполнения программы, причем допускается изменение этих значений. К константам и переменным можно обращаться по именам. Литерал
не имеет идентификатора и представляется в тексте программы непосредственно значением. Тип
определяет множество значений, которые могут принимать элементы данных, и совокупность допустимых над ними операций. В этой и четырех последующих главах приводится подробное описание всех типов.
1.1 Простые типы
К простым типам относятся порядковые, вещественные типы и тип дата-время. Порядковые типы
отличаются тем, что каждый из них имеет конечное количество возможных значений. Эти значения можно определенным образом упорядочить (отсюда - название типов) и, следовательно, с каждым из них можно сопоставить некоторое целое число - порядковый номер значения. Вещественные типы
, строго говоря, тоже имеют конечное число значений, которое определяется форматом внутреннего представления вещественного числа. Однако количество возможных значений вещественных типов настолько велико, что сопоставить с каждым из них целое число (его номер) не представляется возможным. Тип дата-время
предназначен для хранения даты и времени. Фактически для этих целей он использует вещественный формат. 1.1.1 Порядковые типы
К порядковым типам относятся (см. рис. 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 - Целые типы Типы 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 - Стандартные процедуры и функции, применимые к целым типам При действиях с целыми числами тип результата будет соответствовать типу операндов, а если операнды относятся к различным целым типам - общему типу, который включает в себя оба операнда. Например, при действиях с 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.1.2 Вещественные типы
В отличие от порядковых типов, значения которых всегда сопоставляются с рядом целых чисел и, следовательно, представляются в ПК абсолютно точно, значения вещественных типов определяют произвольное число лишь с некоторой конечной точностью, зависящей от внутреннего формата вещественного числа. Таблица 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
полностью совместимы с любыми другими вещественными типами: над ними определены все вещественные операции, они могут использоваться как аргументы математических функций и т. д. Наиболее подходящей областью применения этих типов являются бухгалтерские расчеты. 1.1.3 Тип дата-время
Тип дата-время определяется стандартным идентификатором TDateTime
и предназначен для одновременного хранения и даты, и времени. Во внутреннем представлении он занимает 8 байт и подобно currency
представляет собой вещественное число с фиксированной дробной частью: в целой части числа хранится дата, в дробной - время. Дата определяется как количество суток, прошедших с 30 декабря 1899 года, а время - как часть суток, прошедших с 0 часов, так что значение 36444,837 соответствует дате 11.10.1999 и времени 20:05. Количество суток может быть и отрицательным, однако значения меньшие -693594 (соответствует дате 00.00.0000 от Рождества Христова) игнорируются функциями преобразования даты к строковому типу. Над данными типа TDateTime
определены те же операции, что и над вещественными числами, а в выражениях этого типа могут участвовать константы и переменные целого и вещественного типов. Поскольку тип TDateTime
совместим с форматом вещественных чисел, можно без труда определить дату, отстоящую от заданной на сколько-то дней вперед или назад: для этого достаточно соответственно прибавить к заданной дате или отнять от нее нужное целое число. 1.2 Структурированные типы
Любой из структурированных типов (а в Object Pascal их четыре: массивы, записи, множества и файлы) характеризуется множественностью образующих этот тип элементов. Каждый элемент, в свою очередь, может принадлежать структурированному типу, что позволяет говорить о возможной вложенности типов. В Object Pascal допускается произвольная глубина вложенности типов, однако суммарная длина любого из них во внутреннем представлении не должна превышать 2 Гбайт . В целях совместимости со стандартным Паскалем в Object Pascal разрешается перед описанием структурированного типа ставить зарезервированное слово packed
, предписывающее компилятору по возможности экономить память, отводимую под объекты структурированного типа; но компилятор фактически игнорирует это указание: “упаковка” данных в Object Pascal осуществляется автоматачески везде, где это возможно. 1.2.1 Массивы
Массивы в Object Pascal во многом схожи с аналогичными типами данных в других языках программирования. Отличительная особенность массивов заключается в том, что все их компоненты суть данные одного типа (возможно, структурированного). Эти компоненты можно легко упорядочить и обеспечить доступ к любому из них простым указанием его порядкового номера. Описание типа массива задается следующим образом: <имя типа> = array [ <сп.инд.типов> ] of <тип>; Здесь <имя типа> - правильный идентификатор; array, of
- зарезервированные слова {массив, из); <сп.инд.типов> - список из одного или нескольких индексных типов, разделенных запятыми; квадратные скобки, обрамляющие список, - требование синтаксиса; <тип> - любой тип Object Pascal. В качестве индексных типов в Object Pascal можно использовать любые порядковые типы, имеющие мощность не более 2 Гбайт (т. е. кроме LongWord
и Int64
) Глубина вложенности структурированных типов вообще, а, следовательно, и массивов - произвольная, поэтому количество элементов в списке индексных типов (размерность массива) не ограничено, однако суммарная длина внутреннего представления любого массива не может быть больше 2 Гбайт. В памяти ПК элементы массива следуют друг за другом так, что при переходе от младших адресов к старшим наиболее быстро меняется самый правый индекс массива. В Object Pascal можно одним оператором присваивания передать все элементы одного массива другому массиву того же типа. 1.2.2 Записи
Запись
- это структура данных, состоящая из фиксированного количества компонентов, называемых полями записи. В отличие от массива компоненты (поля) записи могут быть различного типа. Чтобы можно было ссылаться на тот или иной компонент записи, поля именуются. Структура объявления типа записи такова: <имятипа> = record <сп.полей> end; Здесь <имя типа> - правильный идентификатор; record/ end
- зарезервированные слова {запись, конец); <сп.полей> - список полей; представляет собой последовательность разделов записи, между которыми ставится точка с запятой. Каждый раздел записи состоит из одного или нескольких идентификаторов полей, отделяемых друг от друга запятыми. Предложение case ... of
, открывающее вариантную часть, внешне похоже на соответствующий оператор выбора, но на самом деле лишь играет роль своеобразного служебного слова, обозначающего начало вариантной части. Именно поэтому в конце вариантной части не следует ставить end
как пару к case...of
. (Поскольку вариантная часть - всегда последняя в записи, за ней все же стоит end, но лишь как пара к record). Ключ выбора в предложении case…of
фактически игнорируется компилятором: единственное требование, предъявляемое к нему в Object Pascal, состоит в том, чтобы ключ определял некоторый стандартный или предварительно объявленный порядковый тип. Имена полей должны быть уникальными в пределах той записи, где они объявлены, однако, если записи содержат поля-записи, т. е. вложены одна в другую, имена могут повторяться на разных уровнях вложения.
1.2.3 Множества
Множества
- это наборы однотипных логически связанных друг с другом объектов. Характер связей между объектами лишь подразумевается программистом и никак не контролируется Object Pascal. Количество элементов, входящих во множество, может меняться в пределах от 0 до 256 (множество, не содержащее элементов, называется пустым). Именно непостоянством количества своих элементов множества отличаются от массивов и записей. Два множества считаются эквивалентными тогда и только тогда, когда все их элементы одинаковы, причем порядок следования элементов в множестве безразличен. Если все элементы одного множества входят также и в другое, говорят о включении первого множества во второе. Пустое множество включается в любое другое. Описание типа множества имеет вид: <имя типа> = set of <базовый тип>; Здесь <имя типа> - правильный идентификатор; set, of
- зарезервированные слова (множество, из); <базовый тип> - базовый тип элементов множества, в качестве которого может использоваться любой порядковый тип, кроме Word, Integer, Longint, Int64
. Для задания множества используется так называемый конструктор множества: список спецификаций элементов множества, отделенных друг от друга запятыми; список обрамляется квадратными скобками. Спецификациями элементов могут быть константы или выражения базового типа, а также тип-диапазон того же базового типа. Внутреннее устройство множества таково, что каждому его элементу ставится в соответствие один двоичный разряд (один бит); если элемент включен во множество, соответствующий разряд имеет значение 1, в противном случае - 0. В то же время минимальной единицей памяти является один байт, содержащий 8 бит, поэтому компилятор выделил множествам по одному байту, и в результате мощность каждого из них стала равна 8 элементам. Максимальная мощность множества - 256 элементов. Для таких множеств компилятор выделяет по 16 смежных байт. И еще один эксперимент: измените диапазон базового типа на 1..256. Хотя мощность этого типа составляет 256 элементов, при попытке компиляции программы компилятор сообщит об ошибке: Sets may have at most 256 elements (Множества могут иметь не более 256 элементов) т. к. нумерация элементов множества начинается с нуля независимо от объявленной в программе нижней границы. Компилятор разрешает использовать в качестве базового типа целочисленный тип-диапазон с минимальной границей 0 и максимальной 255 или любой перечисляемый тип не более чем с 256 элементами (максимальная мощность перечисляемого типа - 65536 элементов). 1.3 Строки
Для обработки текстов в Object Pascal используются следующие типы: короткая строка shortString
или string [n]
, где n <= 255; длинная строка string
; широкая строка WideString
; нуль-терминальная строка pchar
. Общим для этих типов является то, что каждая строка трактуется как одномерный массив символов, количество символов в котором может меняться в работающей программе: для string [n] длина строки меняется от 0 до n, для string
и pchar
- от 0 до 2 Гбайт. В стандартном Паскале используются только короткие строки String [n]
. В памяти такой строке выделяется n+i байт, первый байт содержит текущую длину строки, а сами символы располагаются, начиная со 2-го по счету байта. Поскольку для длины строки в этом случае отводится один байт, максимальная длина короткой строки не может превышать 255 символов. Для объявления короткой строки максимальной длины предназначен стандартный тип ShortString
(эквивалент String
). В Windows широко используются нуль-терминальные строки, представляющие собой цепочки символов, ограниченные символом #о. Максимальная длина такой строки лимитируется только доступной памятью и может быть очень большой. В 32-разрядных версиях Delphi введен новый тип string
, сочетающий в себе удобства обоих типов. При работе с этим типом память выделяется по мере надобности (динамически) и ограничена имеющейся в распоряжении программы доступной памятью. 1.4 Указатели и динамическая память
1.4.1 Динамическая память
Динамическая память
- это оперативная память ПК, предоставляемая программе при ее работе. Динамическое размещение данных означает использование динамической памяти непосредственно при работе программы. В отличие от этого статическое размещение осуществляется компилятором Object Pascal в процессе компиляции программы. При динамическом размещении заранее не известны ни тип, ни количество размещаемых данных. 1.4.2 Указатели
Оперативная память ПК представляет собой совокупность ячеек для хранения информации - байтов, каждый из которых имеет собственный номер. Эти номера называются адресами, они позволяют обращаться, к любому байту памяти. Object Pascal предоставляет в распоряжение программиста гибкое средство управления динамической памятью - так называемые указатели. Указатель - это переменная, которая в качестве своего значения содержит адрес байта памяти. С помощью указателей можно размещать в динамической памяти любой из известных в Object Pascal типов данных. Лишь некоторые из них (Byte, Char, ShortInt, Boolean
) занимают во внутреннем представлении один байт, остальные - несколько смежных. Поэтому на самом деле указатель адресует лишь первый байт данных. Как правило, указатель связывается с некоторым типом данных. Такие указатели будем называть типизированными. Для объявления типизированного указателя используется значок ^, который помещается перед соответствующим типом. В Object Pascal можно объявлять указатель и не связывать его при этом с каким-либо конкретным типом данных. Для этого служит стандартный тип pointer
, например: Указатели такого рода будем называть нетипизированньти. Поскольку нетипизированные указатели не связаны с конкретным типом, с их помощью удобно динамически размещать данные, структура и тип которых меняются в ходе работы программы. Как уже говорилось, значениями указателей являются адреса переменных в памяти, поэтому следовало бы ожидать, что значение одного указателя можно передавать другому. На самом деле это не совсем так. В Object Pascal можно передавать значения только между указателями, связанными с одним и тем же типом данных. 1.4.3 Выделение и освобождение динамической памяти
Вся динамическая память в Object Pascal рассматривается как сплошной массив байтов, который называется кучей. Память под любую динамически размещаемую переменную выделяется процедурой New. Параметром обращения к этой процедуре является типизированный указатель. В результате обращения указатель приобретает значение, соответствующее адресу, начиная с которого можно разместить данные. Значение, на которое указывает указатель, т. е. собственно данные, размещенные в куче, обозначаются значком ^, который ставится сразу за указателем. Если за указателем нет значка ^, то имеется в виду адрес, по которому размещены данные. Имеет смысл еще раз задуматься над только что сказанным: значением любого указателя является адрес, а чтобы указать, что речь идет не об адресе, а о тех данных, которые размещены по этому адресу, за указателем ставится ^ (иногда об этом говорят как о разыменовании указателя). Динамически размещенные данные можно использовать в любом месте программы, где это допустимо для констант и переменных соответствующего типа Динамическую память можно не только забирать из кучи, но и возвращать обратно. Для этого используется процедура Dispose. Например, операторы Dispose(pJ);
Dispose(pR);
вернут в кучу память, которая ранее была закреплена за указателями pJ и pR (см. выше). Замечу, что процедура Dispose (pPtr) не изменяет значения указателя pPtr, а лишь возвращает в кучу память, ранее связанную с этим указателем. Однако повторное применение процедуры к свободному указателю приведет к возникновению ошибки периода исполнения. Освободившийся указатель программист может пометить зарезервированным словом nil. 1.5 Псевдонимы типов
Для любого типа можно объявить сколько угодно псевдонимов. Например: TMyInteger = Integer; В дальнейшем псевдоним можно использовать так же, как и базовый тип: Mylnt: TMyInteger; Mylnt:= 2*Round(pi); Такого рода псевдонимы обычно используются для повышения наглядности кода программы. Однако в Object Pascal можно объявлять строго типизированные псевдонимы добавлением зарезервированного слова type перед именем базового типа: TMyIntegerType = type Integer; MylntVar: TMyIntegerType; С точки зрения компилятора, типизированные псевдонимы совместимы с базовым типом в различного рода выражениях, но фактически они объявляют новый тип данных, поэтому их нельзя использовать в качестве формальных параметров обращения к подпрограммам вместо базового типа. Если, например, объявленапроцедура function MylntFunc(APar: integer): Integer; то такое обращение к ней MylntFunc(MylntVar) будет расценено компилятором как ошибочное. Строго типизированные псевдонимы заставляют компилятор вырабатывать информацию о типе для этапа прогона программы (RTTI - Run-Time Type Information). Эта информация обычно используется средой Delphi для обеспечения функционирования разного рода редакторов.
Название
Длина, байт
Диапазон значений
Cardinal
4
0. .. 2 147 483 647
Byte
1
0...255
Shortint
1
-128...+127
Smallint
2
-32 768...+32 767
Word
2
0...65 535
Integer
4
Longint
4
-2 147 483 648...+2 147 483 647
Int64
8
-9*1018...+9*1018
LongWord
4
0. . .4 294 967 295
Обращение
Тип результата
Действие
abs (x)
x
Возвращает модуль x
chr(b)
Char
Возвращает символ по его коду
dec (vx [, i])
-
Уменьшает значение vx на i, а при отсутствии i - на 1
inc(vx[,i])
-
Увеличивает значение vx на i, а при отсутствии i -на 1
Hi(w)
Byte
Возвращает старший бант аргумента
Hi(I)
То же
Возвращает третий по счету байт
Lo(i)
“
Возвращает младший байт аргумента
Lo(w)
“
То же
odd(l)
Boolean
Возвращает True, если аргумент-нечетное число
Random(w)
Как у параметра
Возвращает псевдослучайное число, равномерно распределенное в диапазоне 0...(w-l)
sqr(x)
X
Возвращает квадрат аргумента
swap(i)
Integer
Меняет местами байты в слове
swap (w)
Word
Тоже
Код
Символ
Код.
Символ
Код.
Символ
Код
Символ
0
NUL
32
BL
64
@
96
"
1
ЗОН
33
!
65
А
97
а
2
STX
34
“
66
В
98
b
3
ЕТХ
35
#
67
С
99
с
4
EOT
36
$
68
D
100
d
5
ENQ
37
%
69
Е
101
е
6
ACK
38
&
70
F
102
f
7
BEL
39
"
71
G
103
д
8"
BS
40
(
72
Н
104
h
9
HT
41
)
73
I
105
i
10
LF
42
*
74
J
106
j
11
VT
43
+
75
К
107
k
12
FF
44
F
76
L
108
1
13
CR
45
-
77
М
109
m
14
SO
46
78
N
110
n
15
SI
47
/
79
0
111
о
16
DEL
48
0
80
Р
112
P
17
DC1
49
1
81
Q
113
q
18
DC2
50
2
82
R
114
r
19
DC3
51
3
83
S
115
s
20
DC 4
52
4
84
Т
116
t
21
NAK
53
5
85
U
117
u
22
SYN
54
6
86
V
118
v
23
ETB
55
7
87
W
119
W
24
CAN
56
8
88
х
120
x
25
EM
57
9
89
Y
121
У
26
SUB
58
:
90
Z
.122
z
27
ESC
59
;
91
t
123
{
28
FS
60
<
92
\
124
1
29
GS
61
=
93
]
125
}
30
RS
62
>
94
Л
126
~
31
US
63
F
95
127
r