Процедурные типы данных
Наряду с уже известными типами данных в языке Delphi введен так называемый процедурный тип, с помощью которого обычные процедуры и функции можно интерпретировать как некоторую разновидность переменных. Определение процедурного типа состоит из зарезервированного слова procedure или function, за которым следует полное описание параметров. Для функции дополнительно указывается тип результата. Символические имена параметров никакой роли не играют, поскольку нигде не используются.
type
TProc = procedure (X, Y: Integer);
TFunc = function (X, Y: Integer): Boolean;
Определив процедурный тип, можно непосредственно перейти к так называемым процедурным переменным. Они объявляются точно так же, как и обычные переменные.
var
P: TProc;
F: TFunc;
При работе с процедурной переменной важно понимать, что она не дублирует код подпрограммы, а содержит лишь ее адрес. Если обратиться к такой переменной как к подпрограмме, произойдет выполнение подпрограммы, адрес которой записан в переменной.
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
function Power(X, Y: Double): Double;
begin
Result:= Exp(Y * Ln(X));
end;
type
TFunc = function (X, Y: Double): Double;
var
F: TFunc;
begin
F:= Power; // В переменную F заносится адрес функции Power
Writeln('2 power 4 = ', F(2, 4)); // Вызов Power посредством F
Writeln('Press Enter to exit...');
Readln;
end.
Type //программа строящая таблицу умножения
top=function(a,b:integer):integer;
procedure printtable(n:byte;op:top);
var
i,j:byte;
begin
for i:=1 to n do begin
write (i:5,'|');
for j:=1 to n do write(op(i,j):5);
writeln;
end;
end;
function Mul(a,b:integer):integer;
begin
mul:=a*b;
end;
begin
printtable(9,mul);
readln;
end.
Билет 6
Перечисляемые типы данных
Перечисляемый тип данных представляет собой список значений, которые может принимать переменная этого типа. Каждому значению поставлен в соответствие идентификатор, используемый в программе для указания этого значения.
type
TDirection = (North, South, East, West);
На базе типа TDirection можно объявить переменную Direction и присвоить ей значение:
var
Direction: TDirection;
begin
Direction:= North;
end.
На самом деле за идентификаторами значений перечисляемого типа стоят целочисленные константы. По умолчанию, первая константа равна 0, вторая - 1 и т.д. Существует возможность явно назначить значения идентификаторам:
type
TSizeUnit = (Byte = 1, Kilobyte = 1024 * Byte, Megabyte = Kilobyte * 1024,
Gigabyte = Megabyte * 1024);
Интервальные типы данных
Интервальный тип данных задается двумя константами, ограничивающими диапазон значений для переменных данного типа. Обе константы должны принадлежать одному из стандартных порядковых типов (но не вещественному и не строковому). Значение первой константы должно быть обязательно меньше значения второй. Например, определим интервальный тип TDigit:
type
TDigit = 0..9;
var
Digit: TDigit;
begin
Digit:= 5;
Digit:= 10; // Ошибка! Выход за границы диапазона
end.
В операциях с переменными интервального типа данных компилятор генерирует код проверки на принадлежность диапазону, поэтому последний оператор вызовет ошибку. Это очень удобно при отладке, но иногда отрицательно сказывается на скорости работы программы. Для отключения контроля диапазона откройте окно Project Options, выберите страницу Compiler и снимите пометку пункта Range Checking.
Данные перечисляемых и интервальных типов занимают в памяти 1, 2 или 4 байта в зависимости от диапазона значений типа. Например, если диапазон значений не превышает 256, то элемент данных занимает один байт памяти.
Билет 7
Булевские типы данных
Булевские типы данных названы так в честь Георга Буля (George Boole), одного из авторов формальной логики. Диапазон значений данных булевских типов представлен двумя предопределенными константами: True - истина и False - ложь.
Тип данных Диапазон значений Объем памяти (байт)
Boolean False (0), True (1) 1
ByteBool False (0), True (не равно 0 1
WordBool False (0), True (не равно 0) 2
LongBool False (0), True (не равно 0) 4
Пример описания булевских данных:
var
Flag: Boolean;
WordFlag: WordBool;
LongFlag: LongBool;
Булевские типы данных широко применяются в логических выражениях и в выражениях отношения. Переменные типа Boolean используются для хранения результатов логических выражений и могут принимать только два значения: False и True (стандартные идентификаторы). Булевские типы данных ByteBool, WordBool и LongBool введены в язык Delphi специально для совместимости с другими языками, в частности с языками C и C++. Все булевские типы данных совместимы друг с другом и могут одновременно использоваться в одном выражении.
Составной оператор
Составной оператор представляет собой группу из произвольного числа операторов, отделенных друг от друга точкой с запятой и заключенную в так называемые операторные скобки - begin и end:
begin
<оператор 1>;
<оператор 2>;
…
<оператор N>
end
Частным случаем составного оператора является тело следующей программы:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
X, Y: Integer;
begin
X:= 4;
Y:= 6;
Writeln(X + Y);
Writeln('Press Enter to exit...');
Readln; // Точка с запятой после этого оператора не обязательна
end.
Хотя символ точки с запятой служит разделителем между операторами и перед словом end может опускаться, мы рекомендуем ставить его в конце каждого оператора (как в примере), чтобы придать программе более красивый вид и избежать потенциальных ошибок при наборе текста.
Составной оператор может находиться в любом месте программы, где разрешен простой оператор. Он широко используется с условными операторами и операторами повтора.
Билет 8
Символьные типы данных
Символьные типы применяются для описания данных, значением которых является буква, цифра, знак препинания и другие символы. Существуют два фундаментальных символьных типа данных: AnsiChar и WideChar (таблица 2.3). Они соответствуют двум различным системам кодировки символов. Данные типа AnsiChar занимают один байт памяти и кодируют один из 256 возможных символов расширенной кодовой таблицы ANSI, в то время как данные типа WideChar занимают два байта памяти и кодируют один из 65536 символов кодовой таблицы Unicode. Кодовая таблица Unicode - это стандарт двухбайтовой кодировки символов. Первые 256 символов таблицы Unicode соответствуют таблице ANSI, поэтому тип данных AnsiChar можно рассматривать как подмножество WideChar.
Фундаментальные типы данных:
Тип данных Диапазон значений Объем памяти (байт)
AnsiChar Extended ANSI character set 1
WideChar Unicode character set 2
Обобщенный тип данных:
Тип данных Диапазон значений Формат (байт)
Char Same as AnsiChar's range 1*
ПРИМЕЧАНИЕ
* - Тип данных Char является обобщенным и соответствует типу AnsiChar. Однако следует помнить, что в будущем тип данных Char может стать эквивалентным типу данных WideChar, поэтому не следует полагаться на то, что символ занимает в памяти один байт.
Пример описания переменной символьного типа:
var
Symbol: Char;
В программе значения переменных и констант символьных типов заключаются в апострофы (не путать с кавычками!), например:
Symbol:= 'A'; // Переменной Symbol присваивается буква A
НЕТИПИЗИРОВАННЫЕ
Существует разновидность параметров без типа. Они называются нетипизированными и предназначены для передачи и для приема данных любого типа. Нетипизированные параметры описываются с помощью ключевых слов const и var, при этом тип данных опускается:
procedure JustProc(const X; var Y; out Z);
Внутри подпрограммы тип таких параметров не известен, поэтому программист должен сам позаботиться о правильной интерпретации переданных данных. Заметим, что при вызове подпрограмм на место нетипизированных параметров (в том числе и на место нетипизированных const-параметров) можно подставлять только переменные.
Передача фактических аргументов в подпрограмму осуществляется через специальную область памяти - стек. В стек помещается либо значение передаваемого аргумента (передача значения), либо адрес аргумента (передача ссылки на значение). Конкретный способ передачи выбирается компилятором в зависимости от того, как объявлен параметр в заголовке подпрограммы.
Билет 9
Строковые переменные
Строковая переменная объявляется с помощью зарезервированного слова string или с помощью идентификатора типа данных AnsiString, например:
var
FileName: string;
EditText: AnsiString;
Строку можно считать бесконечной, хотя на самом деле ее длина ограничена 2 ГБ. В зависимости от присваиваемого значения строка увеличивается и сокращается динамически. Это удобство обеспечивается тем, что физически строковая переменная хранит не сами символы, а адрес символов строки в области динамически распределяемой памяти (о динамически распределяемой памяти мы расскажем ниже). При создании строки всегда инициализируются пустым значением (''). Управление динамической памятью при операциях со строками выполняется автоматически с помощью стандартных библиотек языка Delphi.
Вы конечно же можете описывать строковые типы данных и использовать их при объявлении переменных и типизированных констант, например:
type
TName = string;
var
Name: TName;
const
FriendName: TName = 'Alexander';
Символы строки индексируются от 1 до N+1, где N - реальная длина строки. Символ с индексом N+1 всегда равен нулю (#0). Для получения длины следует использовать функцию Length, а для изменения длины - процедуру SetLength (см. ниже).
Для того чтобы в программе обратиться к отдельному символу строки, нужно сразу за идентификатором строковой переменной или константы в квадратных скобках записать его номер. Например, FriendName[1] возвращает значение ‘A’, а FriendName[4] - ‘x’. Символы, получаемые в результате индексирования строки, принадлежат типу Char.
Достоинство строки языка Delphi состоит в том, что она объединяет в себе свойства строки самого языка Delphi и строки языка C. Оперируя строкой, вы оперируете значением строки, а не адресом в оперативной памяти. В то же время строка не ограничена по длине и может передаваться вместо C-строки (как адрес первого символа строки) в параметрах процедур и функций. Чтобы компилятор позволил это сделать, нужно, записывая строку в качестве параметра, преобразовать ее к типу PChar (тип данных, используемый в языке Delphi для описания нуль-терминированных строк языка C). Такое приведение типа допустимо по той причине, что строка всегда завершается нулевым символом (#0), который хоть и не является ее частью, тем не менее всегда дописывается сразу за последним символом строки. В результате формат строки удовлетворяет формату C-строки. О работе с нуль-терминированными строками мы поговорим чуть позже.
Операции над строками
Выражения, в которых операндами служат строковые данные, называются строковыми. Они состоят из строковых констант, переменных, имен функций и строковых операций. Над строковыми данными допустимы операции сцепления и отношения.
Операция сцепления (+) применяется для сцепления нескольких строк в одну строку.
Выражение Результат
'Object' + ' Pascal' 'Object Pascal'
Операции отношения (=, <>, >, <, >=, <=) проводят сравнение двух строковых операндов. Сравнение строк производится слева направо до первого несовпадающего символа, и та строка считается больше, в которой первый несовпадающий символ имеет больший номер в кодовой таблице. Строки считаются равными, если они полностью совпадают по длине и содержат одни и те же символы. Если строки имеют различную длину, но в общей части символы совпадают, считается, что более короткая строка меньше, чем более длинная.
Выражение Результат
'USA' < 'USIS' True { A < I }
'abcde' > 'ABCDE' True
'Office' = 'Office' True
'USIS' > 'US' True
Если короткой строке присваивается значение, длина которого превышает максимально допустимую величину, то все лишние символы справа отбрасываются.
Объявление строки Выражение Значение строки
Name: string[6]; Name:= 'Mark Twain'; 'Mark T'
Допускается смешение в одном выражении операндов строкового и символьного типа, например при сцеплении строки и символа.
Объявление записи
Запись - это составной тип данных, состоящий из фиксированного числа элементов одного или нескольких типов. Описание типа записи начинается словом record и заканчивается словом end. Между ними заключен список элементов, называемых полями, с указанием идентификаторов полей и типа каждого поля:
type
TPerson = record
FirstName: string[20]; // имя
LastName: string[20]; // фамилия
BirthYear: Integer; // год рождения
end;
Идентификаторы полей должны быть уникальными только в пределах записи. Допускается вложение записей друг в друга, т.е. поле записи может быть в свою очередь тоже записью.
Чтобы получить в программе реальную запись, нужно создать переменную соответствующего типа:
var
Friend: TPerson;
Записи можно создавать и без предварительного описания типа, но это делается редко, так как мало отличается от описания полей в виде отдельных переменных.
Доступ к содержимому записи осуществляется посредством идентификаторов переменной и поля, разделенных точкой. Такая комбинация называется составным именем. Например, чтобы получить доступ к полям записи Friend, нужно записать:
Friend.FirstName:= 'Alexander';
Friend.LastName:= 'Ivanov';
Friend.BirthYear:= 1991;
ОПЕРАТОР WITH
Обращение к полям записи имеет несколько громоздкий вид, что особенно неудобно при использовании мнемонических идентификаторов длиной более 5 символов. Для решения этой проблемы в языке Delphi предназначен оператор with, который имеет формат:
with <запись> do
<оператор>;
Однажды указав имя записи в операторе with, можно работать с именами ее полей как с обычными переменными, т.е. без указания идентификатора записи перед идентификатором поля:
with Friend do
begin
FirstName:= 'Alexander';
LastName:= 'Ivanov';
BirthYear:= 1991;
end;
Допускается применение оператора присваивания и к записям в целом, если они имеют один и тот же тип. Например,
Friend:= BestFriend;
После выполнения этого оператора значения полей записи Friend станут равными значениям соответствующих полей записи BestFriend.
Билет10
Множества
Объявление множества
Множество - это составной тип данных для представления набора некоторых элементов как единого целого. Область значений множества - набор всевозможных подмножеств, составленных из его элементов. Все элементы множества должны принадлежать однобайтовому порядковому типу. Этот тип называется базовым типом множества.
Для описания множественного типа используется словосочетание set of, после которого записывается базовый тип множества:
type
TLetters = set of 'A'..'Z';
Теперь можно объявить переменную множественного типа:
var
Letters: TLetters;
Можно объявить множество и без предварительного описания типа:
var
Symbols: set of Char;
В выражениях значения элементов множества указываются в квадратных скобках: [2, 3, 5, 7], [1..9], ['A', 'B', 'C']. Если множество не имеет элементов, оно называется пустым и обозначается как [ ]. Пример инициализации множеств:
const
Vowels: TLetters = ['A', 'E', 'I', 'O', 'U'];
begin
Letters:= ['A', 'B', 'C'];
Symbols:= [ ]; { пустое множество }
end;
Количество элементов множества называется мощностью. Мощность множества в языке Delphi не может превышать 256.
Операции над множествами
При работе с множествами допускается использование операций отношения (=, <>, >=, <=), объединения, пересечения, разности множеств и операции in.
Операции сравнения (=, <>). Два множества считаются равными, если они состоят из одних и тех же элементов. Порядок следования элементов в сравниваемых множествах значения не имеет. Два множества A и B считаются не равными, если они отличаются по мощности или по значению хотя бы одного элемента.
Выражение Результат
[1, 2] <> [1, 2, 3] True
[1, 2] = [1, 2, 2] True
[1, 2, 3] = [3, 2, 1] True
[1, 2, 3] = [1..3] True
Операции принадлежности (>=, <=). Выражение A >= B равно True, если все элементы множества B содержатся в множестве A. Выражение A <= B равно True, если выполняется обратное условие, т.е. все элементы множества A содержатся в множестве B.
Выражение Результат
[1, 2] <= [1, 2, 3] True
[1, 2, 3] >= [1, 2] True
[1, 2] <= [1, 3] False
Операция in. Используется для проверки принадлежности элемента указанному множеству. Обычно применяется в условных операторах.
Выражение Результат
5 in [1..9] True
5 in [1..4, 6..9] False
Операция in позволяет эффективно и наглядно выполнять сложные проверки условий, заменяя иногда десятки других операций. Например, оператор
if (X = 1) or (X = 2) or (X = 3) or (X = 5) or (X = 7) then
можно заменить более коротким:
if X in [1..3, 5, 7] then
Операцию in иногда пытаются записать с отрицанием: X not in S. Такая запись является ошибочной, так как две операции следуют подряд. Правильная запись имеет вид: not (X in S).
Объединение множеств (+). Объединением двух множеств является третье множество, содержащее элементы обоих множеств.
Выражение Результат
[ ] + [1, 2] [1, 2]
[1, 2] + [2, 3, 4] [1, 2, 3, 4]
Пересечение множеств (*). Пересечение двух множеств - это третье множество, которое содержит элементы, входящие одновременно в оба множества.
Выражение Результат
[ ] * [1, 2] [ ]
[1, 2] * [2, 3, 4] [2]
Разность множеств (-). Разностью двух множеств является третье множество, которое содержит элементы первого множества, не входящие во второе множество.
Выражение Результат
[1, 2, 3] - [2, 3] [1]
[1, 2, 3] - [ ] [1, 2, 3]
В язык Delphi введены две стандартные процедуры Include и Exclude, которые предназначены для работы с множествами.
Процедура Include(S, I) включает в множество S элемент I. Она дублирует операцию + (плюс) с той лишь разницей, что при каждом обращении включает только один элемент и делает это более эффективно.
Процедура Exclude(S, I) исключает из множества S элемент I. Она дублирует операцию - (минус) с той лишь разницей, что при каждом обращении исключает только один элемент и делает это более эффективно.
Выражение Результат
S:= [1, 3]; [1, 3]
Include(S, 2); [1, 2, 3]
Exclude(S, 3) [1, 2]
Использование в программе множеств дает ряд преимуществ: значительно упрощаются сложные операторы if, улучшается наглядность программы и понимание алгоритма решения задачи, экономится время разработки программы. Поэтому множества широко используются в библиотеке компонентов среды Delphi.
?
Билет 11
Массивы
Объявление массива
Массив - это составной тип данных, состоящий из фиксированного числа элементов одного и того же типа. Для описания массива предназначено словосочетание array of. После слова array в квадратных скобках записываются границы массива, а после слова of - тип элементов массива, например:
type
TStates = array[1..50] of string;
TCoordinates = array[1..3] of Integer;
После описания типа можно переходить к определению переменных и типизированных констант:
var
States: TStates; { 50 strings }
const
Coordinates: TCoordinates = (10, 20, 5); { 3 integers }
Обратите внимание, что инициализация элементов массива происходит в круглых скобках через запятую.
Массив может быть определен и без описания типа:
var
Symbols: array[0..80] of Char; { 81 characters }
Чтобы получить доступ к отдельному элементу массива, нужно в квадратных скобках указать его индекс, например
Symbols[0]
Объявленные выше массивы являются одномерными, так как имеют только один индекс. Одномерные массивы обычно используются для представления линейной последовательности элементов. Если при описании массива задано два индекса, массив называется двумерным, если n индексов - n-мерным. Двумерные массивы используются для представления таблицы, а n-мерные - для представления пространств. Вот пример объявления таблицы, состоящей из 5 колонок и 20 строк:
var
Table: array[1..5] of array[1..20] of Double;
То же самое можно записать в более компактном виде:
var
Table: array[1..5, 1..20] of Double;
Чтобы получить доступ к отдельному элементу многомерного массива, нужно указать значение каждого индекса, например
Table[2][10]
или в более компактной записи
Table[2, 10]
Эти два способа индексации эквивалентны.
Работа с массивами
Массивы в целом участвуют только в операциях присваивания. При этом все элементы одного массива копируются в другой. Например, если объявлены два массива A и B,
var
A, B: array[1..10] of Integer;
то допустим следующий оператор:
A:= B;
Оба массива-операнда в левой и правой части оператора присваивания должны быть не просто идентичны по структуре, а описаны с одним и тем же типом, иначе компилятор сообщит об ошибке. Именно поэтому все массивы рекомендуется описывать в секции type.
С элементами массива можно работать, как с обычными переменными. В следующей программе элементы численного массива последовательно вводятся с клавиатуры, а затем суммируются. Результат выводится на экран.
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
A: array[1..5] of Double;
Sum: Double;
I: Integer;
begin
for I:= 1 to 5 do Readln(A[I]);
Sum:= 0;
for I:= 1 to 5 do Sum:= Sum + A[I];
Writeln(Sum);
Writeln('Press Enter to exit...');
Readln;
end.
Для массивов определены две встроенные функции - Low и High. Они получают в качестве своего аргумента имя массива. Функция Low возвращает нижнюю, а High - верхнюю границу этого массива. Например, Low(A) вернет значение 1, а High(A) - 5. Функции Low и High чаще всего используются для указания начального и конечного значений в операторе цикла for. Поэтому вычисление суммы элементов массива A лучше переписать так:
for I:= Low(A) to High(A) do Sum:= Sum + A[I];
В операциях с многомерными массивами циклы for вкладываются друг в друга. Например, для инициализации элементов таблицы, объявленной как
var
Table: array[1..5, 1..20] of Double;
требуются два вложенных цикла for и две целые переменные Col и Row для параметров этих циклов:
for Col:= 1 to 5 do
for Row:= 1 to 20 do
Table[Col, Row]:= 0;
Константы
Данные, независимо от типа, имеют некоторое значение и в программе предстают как константы или переменные. Данные, которые получили значение в начале программы и по своей природе изменяться не могут, называются константами. Константами, например, являются скорость света в вакууме и соотношение единиц измерения (метр, сантиметр, ярд, фут, дюйм), которые имеют научно обоснованные или традиционно принятые постоянные значения. Константы описываются с помощью зарезервированного слова const. За ним идет список имен констант, каждому из которых с помощью знака равенства присваивается значение. Одно присваивание отделяется от другого с помощью точки с запятой. Тип константы распознается компилятором автоматически, поэтому его не надо указывать при описании. Примеры констант:
const
DelphiLanguage = 'Object Pascal';
KylixLanguage = DelphiLanguage;
Yard = 914.4;
Foot = 304.8;
После такого описания для обращения к нужному значению достаточно указать лишь имя соответствующей константы.
Значение константы можно задавать и выражением. Эту возможность удобно использовать для комплексного представления какого-либо понятия. Например, временной промежуток, равный одному месяцу, можно задать так:
const
SecondsInMinute = 60;
SecondsInHour = SecondsInMinute * 60;
SecondsInDay = SecondsInHour * 24;
Очевидно, что, изменив базовую константу SecondsInMinute, можно изменить значение константы SecondsInDay.
При объявлении константы можно указать ее тип:
const
Percent: Double = 0.15;
FileName: string = 'HELP.TXT';
Такие константы называются типизированными; их основное назначение - объявление константных значений составных типов данных.
Билет 12
Указатели
Понятие указателя
Все переменные, с которыми мы имели дело, известны уже на этапе компиляции. Однако во многих задачах нужны переменные, которые по мере необходимости можно создавать и удалять во время выполнения программы. С этой целью в языке Delphi организована поддержка так называемых указателей, для которых введен специальный тип данных Pointer.
Не секрет, что любая переменная в памяти компьютера имеет адрес. Переменные, которые содержат адреса других переменных, принято называть указателями. Указатели объявляются точно так же, как и обычные переменные:
var
P: Pointer; // переменная-указатель
N: Integer; // целочисленная переменная
Переменная P занимает 4 байта и может содержать адрес любого участка памяти, указывая на байты со значениями любых типов данных: Integer, Real, string, record, array и других. Чтобы инициализировать переменную P, присвоим ей адрес переменной N. Это можно сделать двумя эквивалентными способами:
P:= Addr(N); // с помощью вызова встроенной функции Addr
или
P:= @N; // с помощью оператора @
В дальнейшем мы будем использовать более краткий и удобный второй способ.
Если некоторая переменная P содержит адрес другой переменной N, то говорят, что P указывает на N. Графически это обозначается стрелкой, проведенной из P в N (рисунок 12 выполнен в предположении, что N имеет значение 10):
Рисунок 12. Графическое изображение указателя P на переменную N
Теперь мы можем изменить значение переменной N, не прибегая к идентификатору N. Для этого слева от оператора присваивания запишем не N, а P вместе с символом ^:
P^:= 10; // Здесь умышленно опущено приведение типа
Символ ^, записанный после имени указателя, называется оператором доступа по адресу. В данном примере переменной, расположенной по адресу, хранящемуся в P, присваивается значение 10. Так как в переменную P мы предварительно занесли адрес N, данное присваивание приводит к такому же результату, что и
N:= 10;
Однако в примере с указателем мы умышленно допустили одну ошибку. Дело в том, что переменная типа Pointer может содержать адреса переменных любого типа, не только Integer. Из-за сильной типизации языка Delphi перед присваиванием мы должны были бы преобразовать выражение P^ к типу Integer:
Integer(P^):= 10;
Согласитесь, такая запись не совсем удобна. Для того, чтобы сохранить простоту и избежать постоянных преобразований к типу, указатель P следует объявить так:
var
P: ^Integer;
При такой записи переменная P по прежнему является указателем, но теперь ей можно присваивать адреса только целых переменных. В данном случае указатель P называют типизированным, в отличие от переменных типа Pointer, которые называют нетипизированными указателями. При использовании типизированных указателей лучше предварительно вводить соответствующий указательный тип данных, а переменные-указатели просто объявлять с этим типом. Поэтому предыдущий пример можно модифицировать следующим образом:
type
PInteger = ^Integer;
var
P: PInteger;
PInteger - это указательный тип данных. Чтобы отличать указательные типы данных от других типов, будем назначать им идентификаторы, начинающиеся с буквы P (от слова Pointer). Объявление указательного типа данных является единственным способом введения указателей на составные переменные, такие как массивы, записи, множества и другие. Например, объявление типа данных для создания указателя на некоторую запись TPerson может выглядеть так:
type
PPerson = ^TPerson;
TPerson = record
FirstName: string[20];
LastName: string[20];
BirthYear: Integer;
end;
var
P: PPerson;
Переменная P, описанная с типом данных PPerson, является указателем и может содержать адрес любой переменной типа TPerson. Впредь все указатели мы будем вводить через соответствующие указательные типы данных. Типом Pointer будем пользоваться лишь тогда, когда это действительно необходимо или оправдано.
Билет 13
Записи
Объявление записи
Запись - это составной тип данных, состоящий из фиксированного числа элементов одного или нескольких типов. Описание типа записи начинается словом record и заканчивается словом end. Между ними заключен список элементов, называемых полями, с указанием идентификаторов полей и типа каждого поля:
type
TPerson = record
FirstName: string[20]; // имя
LastName: string[20]; // фамилия
BirthYear: Integer; // год рождения
end;
Идентификаторы полей должны быть уникальными только в пределах записи. Допускается вложение записей друг в друга, т.е. поле записи может быть в свою очередь тоже записью.
Чтобы получить в программе реальную запись, нужно создать переменную соответствующего типа:
var
Friend: TPerson;
Записи можно создавать и без предварительного описания типа, но это делается редко, так как мало отличается от описания полей в виде отдельных переменных.
Доступ к содержимому записи осуществляется посредством идентификаторов переменной и поля, разделенных точкой. Такая комбинация называется составным именем. Например, чтобы получить доступ к полям записи Friend, нужно записать:
Friend.FirstName:= 'Alexander';
Friend.LastName:= 'Ivanov';
Friend.BirthYear:= 1991;
Обращение к полям записи имеет несколько громоздкий вид, что особенно неудобно при использовании мнемонических идентификаторов длиной более 5 символов. Для решения этой проблемы в языке Delphi предназначен оператор with, который имеет формат:
with <запись> do
<оператор>;
Однажды указав имя записи в операторе with, можно работать с именами ее полей как с обычными переменными, т.е. без указания идентификатора записи перед идентификатором поля:
with Friend do
begin
FirstName:= 'Alexander';
LastName:= 'Ivanov';
BirthYear:= 1991;
end;
Допускается применение оператора присваивания и к записям в целом, если они имеют один и тот же тип. Например,
Friend:= BestFriend;
После выполнения этого оператора значения полей записи Friend станут равными значениям соответствующих полей записи BestFriend.
Записи с вариантами
Строго фиксированная структура записи ограничивает возможность ее применения. Поэтому в языке Delphi имеется возможность задать для записи несколько вариантов структуры. Такие записи называются записями с вариантами. Они состоят из необязательной фиксированной и вариантной частей.
Вариантная часть напоминает условный оператор case. Между словами case и of записывается особое поле записи - поле признака. Оно определяет, какой из вариантов в данный момент будет активизирован. Поле признака должно быть равно одному из расположенных следом значений. Каждому значению сопоставляется вариант записи. Он заключается в круглые скобки и отделяется от своего значения двоеточием. Пример описания записи с вариантами:
type
TFigure = record
X, Y: Integer;
case Kind: Integer of
0: (Width, Height: Integer); // прямоугольник
1: (Radius: Integer); // окружность
end;
Обратите внимание, что у вариантной части нет отдельного end, как этого можно было бы ожидать по аналогии с оператором case. Одно слово end завершает и вариантную часть, и всю запись.
На этом мы пока закончим рассказ о записях, но хотим надеяться, что читатель уже догодался об их потенциальной пользе при организации данных с более сложной структурой.
Оператор ветвления if
Оператор ветвления if - одно из самых популярных средств, изменяющих естественный порядок выполнения операторов программы. Вот его общий вид:
if <условие> then
<оператор 1>
else
<оператор 2>;
Условие - это выражение булевского типа, оно может быть простым или сложным. Сложные условия образуются с помощью логических операций и операций отношения. Обратите внимание, что перед словом else точка с запятой не ставится.
Логика работы оператора if очевидна: выполнить оператор 1, если условие истинно, и оператор 2, если условие ложно. Поясним сказанное на примере:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
A, B, C: Integer;
begin
A:= 2;
B:= 8;
if A > B then
C:= A
else
C:= B;
Writeln('C=', C);
Writeln('Press Enter to exit...');
Readln;
end.
В данном случае значение выражения А > В ложно, следовательно на экране появится сообщение C=8.
У оператора if существует и другая форма, в которой else отсутствует:
if <условие> then <оператор>;
Логика работы этого оператора if еще проще: выполнить оператор, если условие истинно, и пропустить оператор, если оно ложно. Поясним сказанное на примере:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
A, B, C: Integer;
begin
A:= 2;
B:= 8;
C:= 0;
if A > B then C:= A + B;
Writeln('C=', C);
Writeln('Press Enter to exit...');
Readln;
end.
В результате на экране появится сообщение С=0, поскольку выражение А > В ложно и присваивание С:= А + В пропускается.
Один оператор if может входить в состав другого оператора if. В таком случае говорят о вложенности операторов. При вложенности операторов каждое else соответствует тому then, которое непосредственно ему предшествует. Например
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
A: Integer;
begin
Readln(A);
if A >= 0 then
if A <= 100 then
Writeln('A попадает в диапазон 0 - 100.')
else
Writeln('A больше 100.')
else
Writeln('A меньше 0.');
Writeln('Press Enter to exit...');
Readln;
end.
Конструкций со степенью вложенности более 2-3 лучше избегать из-за сложности их анализа при отладке программ.
Билет 14
Понятие файла
С точки зрения пользователя файл - это именованная область данных на диске или любом другом внешнем носителе. В программе файл предстает как последовательность элементов некоторого типа. Так как размер одного файла может превышать объем всей оперативной памяти компьютера, доступ к его элементам выполняется последовательно с помощью процедур чтения и записи.
Для файла существует понятие текущей позиции. Она показывает номер элемента, который будет прочитан или записан при очередном обращении к файлу. Чтение-запись каждого элемента продвигает текущую позицию на единицу вперед. Для большинства файлов можно менять текущую позицию чтения-записи, выполняя прямой доступ к его элементам.
В зависимости от типа элементов различают три вида файла:
файл из элементов фиксированного размера; элементами такого файла чаще всего являются записи;
файл из элементов переменного размера (нетипизированный файл); такой файл рассматривается просто как последовательность байтов;
текстовый файл; элементами такого файла являются текстовые строки.
Для работы с файлом в программе объявляется файловая переменная. В файловой переменной запоминается имя файла, режим доступа (например, только чтение), другие атрибуты. В зависимости от вида файла файловая переменная описывается по-разному.
Для работы с файлом, состоящим из типовых элементов переменная объявляется с помощью словосочетания file of, после которого записывается тип элемента:
var
F: file of TPerson;
К моменту такого объявления тип TPerson должен быть уже описан (см. выше).
Объявление переменной для работы с нетипизированным файлом выполняется с помощью отдельного слова file:
var
F: file;
Для работы с текстовым файлом переменная описывается с типом TextFile:
var
F: TextFile;
Работа с файлами
Наиболее часто приходится иметь дело с текстовым представлением информации, поэтому рассмотрим запись и чтение текстового файла.
Приступая к работе с файлом, нужно первым делом вызвать процедуру AssignFile, чтобы файловой переменной поставить в соответствие имя файла на диске:
AssignFile(F, 'MyFile.txt');
В результате этого действия поля файловой переменной F инициализируются начальными значениями. При этом в поле имени файла заносится строка 'MyFile.txt'.
Так как файла еще нет на диске, его нужно создать:
Rewrite(F);
Теперь запишем в файл несколько строк текста. Это делается с помощью хорошо вам знакомых процедур Write и Writeln:
Writeln(F, 'Pi = ', Pi);
Writeln(F, 'Exp = ', Exp(1));
При работе с файлами первый параметр этих процедур показывает, куда происходит вывод данных.
После работы файл должен быть закрыт:
CloseFile(F);
Рассмотрим теперь, как прочитать содержимое текстового файла. После инициализации файловой переменной (AssignFile) файл открывается с помощью процедуры Reset:
Reset(F);
Для чтения элементов используются процедуры Read и Readln, в которых первый параметр показывает, откуда происходит ввод данных. После работы файл закрывается. В качестве примера приведем программу, р<