Ответы на экзамен 2014 (часть 2)

Экзаменационные билеты по предмету «Программирование»
Информация о работе
  • Тема: Ответы на экзамен 2014 (часть 2)
  • Количество скачиваний: 6
  • Тип: Экзаменационные билеты
  • Предмет: Программирование
  • Количество страниц: 37
  • Язык работы: Русский язык
  • Дата загрузки: 2014-12-30 08:50:55
  • Размер файла: 111.87 кб
Помогла работа? Поделись ссылкой
Ссылка на страницу (выберите нужный вариант)
  • Ответы на экзамен 2014 (часть 2) [Электронный ресурс]. – URL: https://www.sesiya.ru/ekzamenacionnye-bilety/programmirovanie/785-otvety-na-ekzamen-2014-chast-2/ (дата обращения: 17.05.2021).
  • Ответы на экзамен 2014 (часть 2) // https://www.sesiya.ru/ekzamenacionnye-bilety/programmirovanie/785-otvety-na-ekzamen-2014-chast-2/.
Есть ненужная работа?

Добавь её на сайт, помоги студентам и школьникам выполнять работы самостоятельно

добавить работу
Обратиться за помощью в подготовке работы

Заполнение формы не обязывает Вас к заказу

Информация о документе

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

Если Вы являетесь автором текста представленного на данной странице и не хотите чтобы он был размешён на нашем сайте напишите об этом перейдя по ссылке: «Правообладателям»

Можно ли скачать документ с работой

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

1. Строки. Процедуры и функции обработки строковых данных. Примеры.

Строка-последовательность символов, заключённая в апострафы. Для объявления строкового типа используют :strig:
«Переменная»:string[n]
!!!Если максимальный размер не указан, то стандарт =255.
По сути строка длинной k представляет собой массив из k+1 символьных переменных, где 0-й элемент = значению длины строки. Пример :String[k]=array[0..k] ofchar;
Так же как в массиве в строке возможен доступ к отдельным символам строки по номеру их позиций.
Str:string;

Str:=’Строка’;
Str[1]=’С’;
Str[2]=’т’;

Str[6]=’а’;

Вводвывод данных осуществляется с использованием :read (+ln) , write (+ln).
Вводится и выводится строка ЦЕЛИКОМ.
Операции.
Строки можно : присваивать, склеивать, сравнивать.
Присваивание:str:=’Строка’;
Str[6]:=’и’;
Склеивание (конкатенация) : объединение двух строк в одну : +.
Str1:=’Ivan’;
Str2:=’Ivanovich’;
Str3:=str1+’_’+str2; (‘Ivan_Ivanovich’)
Сравнение : произвольные пары строк могут сравниваться с помощью операторов. (сравниваются посимвольно : слева на право).
При обнаружении несовпадений принимается решение по таблице ASCII.
‘Pascal’<’pascal’
!!! Если две строки имеют различную длину, но совпадают до последнего символа более короткой строки , то последняя строка считается меньшей.
!!! Две сроки – равные , если 1) у них одинаковая длина, 2) Символы совпадают.

Стандартные процедуры и функции обработки строк :
• Length(s:string):integer
Функция возвращает в качестве результата значение текущей длины строки-параметра
Пример.
n := length(Pascal); {n будетравно 6}

• Concat(s1,[s2,...,sn]:string):string
Функция выполняет слияние строк-параметров, которых может быть произвольное количество. Каждый параметр является выражением строкового типа. Если длина строки-результата превышает 255 символов, то она усекается до 255 символов. Данная функция эквивалентна операции конкатенации "+" и работает немного менее эффективно, чем эта операция.

• Copy(s:string; index:integer; count:integer):string
Функция возвращает подстроку, выделенную из исходной строки s, длиной count символов, начиная с символа под номером index.
Пример.
s := Система Turbo Pascal;
s2 := copy(s, 1, 7); {s2 будет равно Система}
s3 := copy(s, 9, 5); {s3 будетравно Turbo}
s4 := copy(s, 15, 6); {s4 будетравно Pascal}

• Delete(var s:string; index,count:integer)
Процедура удаляет из строки-параметра s подстроку длиной count символов, начиная с символа под номером index.
Пример.
s := Система Turbo Pascal;
delete(s,8,6); {s будет равно Система Pascal}

• Insert(source:string; var s:string;index:integer)
Процедура предназначена для вставки строки source в строку s, начиная с символа index этой строки.
Пример.
s := Система Pascal;
insert(Turbo ,s,9); {s будет равно Система Turbo Pascal}

• Pos(substr,s:string):byte
Функция производит поиск в строке s подстроки substr. Результатом функции является номер первой позиции подстроки в исходной строке. Если подстрока не найдена, то функция возвращает 0.
Пример.
s := Система Turbo Pascal;
x1 := pos(Pascal, s); {x1 будетравно 15}
x2 := pos(Basic, s); {x2 будетравно 0}

• Str(X: арифметическое выражение; var st: string)
Процедура преобразует численное выражение X в его строковое представление и помещает результат в st.

• Val(st: string; x: числоваяпеременная; var code: integer)
Процедура преобразует строковую запись числа, содержащуюся в st, в числовое представление, помещая результат в x. x - может быть как целой, так и действительной переменной. Если в st встречается недопустимый (с точки зрения правил записи чисел) символ, то преобразование не происходит, а в code записывается позиция первого недопустимого символа. Выполнение программы при этом не прерывается, диагностика не выдается. Если после выполнения процедуры code равно 0, то это свидетельствует об успешно произошедшем преобразовании.

Дополнительные (связанные с типом char) :
• Chr(n: byte): char
Функция возвращает символ по коду, равному значению выражения n. Если n можно представить как числовую константу, то можно также пользоваться записью #n.

• Ord(ch: char): byte;
В данном случае функция возвращает код символа ch.

• UpCase(c: char): char;
Если c - строчная латинская буква, то функция возвращает соответствующую прописную латинскую букву, в противном случае символ c возвращается без изменения.

2. Записи. Описание типа–запись. Описание переменной записного типа. Обращение к элементу записи. Оператор присоединения. Примеры.

Для записи комбинации объектов разных типов в Pascal применяется комбинированный тип данных – запись.
Запись представляет собой наиболее общий и гибкий структурированный тип данных, так как она может быть образована из неоднотипных компонентов и в ней явным образом выражена связь между элементами данных, характеризующими реальный объект.
Запись – это структурированный тип данных, состоящий из фиксированного числа компонентов одного или нескольких типов. Определение типа записи начинается идентификатором record и заканчивается зарезервированным словом end. Между ними располагается список компонентов, называемых полями, с указанием идентификаторов полей и типа каждого поля.
Формат:
type
<имя типа> = record
<идентификатор поля>:<тип компонента>;
<идентификатор поля>:<тип компонента>
end;

var
<идентификатор, ...> : <имя типа>;
Пример:
typeСаr = record
Number : integer; {Номер}
Marka : string[20]; {Маркаавтомобиля}
FIO : string[40]; {Фамилия, инициалывладельца}
Address : string[60] {Адресвладельца}
end;
var
М, V : Саr;
В данном примере запись Саr содержит четыре компонента: номер, название марки машины, фамилию владельца и его адрес. Доступ к полям записи осуществляется через переменную типа «запись». В нашем случае это переменные М и V типа Саr.
Идентификатор поля должен быть уникален только в пределах записи, однако во избежание ошибок лучше делать его уникальным в пределах всей программы. Объем памяти, необходимый для записи, складывается из длин полей.
Значения полей записи могут использоваться в выражениях. Имена отдельных полей не применяются по аналогии с идентификаторами переменных, поскольку может быть несколько записей одинакового типа. Обращение к значению поля осуществляется с помощью идентификатора переменной и идентификатора поля, разделенных точкой. Такая комбинация называется составным именем. Например, чтобы получить доступ к полям записи Саr, надо записать:
М.Number
M.Marka
M.FIO
M.Address
Составное имя можно использовать везде, где допустимо применение типа поля. Для присваивания полям значений используется оператор присваивания.
Пример:
М.Number := 1678;
М.Marka := ТАЗ - 24;
M.FIO := Демьяшкин В.А.1;
M.Address := ул. Пушкина 12 - ЗГ;
Составные имена можно использовать, в частности, в операторах ввода-вывода:
Read(M.Number, M.Marka, M.FIO, M.Address);
Write(M.Number:4, M.Marka:7, M.FI0:12, M.Address:25);

Допускается применение оператора присваивания и к записям в целом, если они имеют одинаковый тип. Например,
V := М;
После выполнения этого оператора значения полей записи V станут равны значениям соответствующих полей записи М.
В ряде задач удобно пользоваться массивами из записей. Их можно описать следующим образом:
type
Person = record
FIO : string[20];
Age : 1 .. 99;
Prof : string[30]
end;
var
List : array[1..5O] of Person;

Обращение к полям записи имеет несколько громоздкий вид, что особенно неудобно при использовании мнемонических идентификаторов длиной более пяти символов. Для решения этой проблемы в языке Pascal предназначен оператор with(оператор присоединения), который имеет следующий формат:
with <переменная типа запись> do <оператор>;
Один раз указав переменную типа запись в операторе with, можно работать с именами полей как с обычными переменными, т.е. без указания перед идентификатором поля имени переменной, определяющей запись.

with rec do begin
FIO:=ИвановА.А.;
TEL:=2223322;
end;
Такая алгоритмическая конструкция полностью идентична следующей:
rec.FIO:=Иванов А.А.;
rec.TEL:=2223322;

3. Множества. Конструктор множества. Примеры использования множеств при обработке строковых данных.


Объявление множеств
В языке программирования Pascal существует понятие множества, имеющее смысл некоторого собрания элементов, одно и того же базового типа. Базовый тип определяет перечень всех элементов, которые вообще могут содержаться в данном множестве. В качестве базового типа может выступать любой простой порядковый тип. Но вещественные числа (real не порядковый тип) и строки (не простой и не порядковый тип) не могут быть элементами множества.
Размер множества в Turbo Pascal всегда ограничен некоторым предельно допустимым количеством элементов. Во множествах допускаются только такие элементы, порядковые значения которых не выходят за границы 0..255. Для целочисленных множеств это означает, что в них могут присутствовать только числа от 0 до 255. Отрицательные элементы множеств в Turbo Pascal не допускаются. Поэтому базовыми типами не могут быть типы shortint, integer, longint. Если же необходимо множество целочисленных объектов, то базовый тип должен объявлен как диапазон типа byte. Для множеств, содержащих символы, подобных затруднений нет, поскольку базовым типом для них является char (а в нем 256 значений с порядковыми номерами от 0 до 255).
В математике для обозначения множества используют фигурные скобки (например, {4, 7, 12}), в Паскаль — квадратные (например, [1, 3, 5]). Порядок элементов во множестве не имеет значения. Так, записав [3, 6, 9] или [9, 3, 6], мы будем иметь дело с одним и тем же множеством. Более того, многократное повторение одного и того же элемента не меняет множество. Например, [4, 7, 3] и [3, 7, 4, 4] – это одно и то же множество.
По форме записи объявление переменной типа множество сходно с объявлением одномерного массива:
var
имя: setofтип;
Например, объявление переменной ch, рассматриваемой как множество с базовым типом char, имеет вид:
var
ch: setofchar;
В отличие от элементов массива, элементы множества не упорядочены и не имеют индексов.
Можно сначала объявить тип множества, а потом использовать его для объявления переменных:
type
t_ch = setofchar;
var
ch1, ch2: t_ch;
Довольно часто в качестве базового типа множества используется тип перечисления или некоторый его диапазон:
type
week_days = (Mon, Tue, Wed, Thu, Fri);
var
work_days: setof week_days;
lett: setof A..Z;
Объявление переменной-множества не дает ей определенного значения.
Построение множества
Чтобы во множестве появились элементы, необходимо выполнить оператор присваивания, в левой части которого стоит имя переменной-множества, а в правой — конструктор множества или некоторое выражение над множествами.
Конструктор множества — это заключенный в квадратные скобки перечень элементов, разделенных запятыми. В качестве элементов могут использоваться диапазоны значений:
type
week_days = (Mon, Tue, Wed, Thu, Fri);
var
work_days: setof week_days;
lett: setof A..Z;
begin
work_days := [Mon, Wed, Thu];
lett := [C, E..M, Z]
end.
Следует помнить, что при задании множества порядок его элементов безразличен, но при задании диапазона такой порядок важен.
Множество, в котором нет элементов, называется пустым (или нуль-множеством). В языке программирования Паскаль обозначается квадратными скобками, между которыми нет элементов:
work_days := [ ];
Множество может быть объявлено типизированной константой, для чего в описании после знака равенства следует указать конструктор множества. Например:
const lett: setof [а..я] = [а, е, и, о, у, ы, э, ю, я];
В данном случае оператор описывает множество, элементами которого могут быть буквы русского алфавита, с записью в него начального значения, которое представляет собой множество гласных букв.
Конструируя множества, можно использовать и переменные при условии, что их текущие значения попадают в диапазон базового типа множества. Так, если ch1 иch2 имеют тип char, то допустима следующая последовательность операторов:
ch1 := A;
ch2 := K;
chs := [ch1, ch2, M];
В результате получится множество [A, K, M].
Элементы множества нельзя вводить и выводить. Для организации ввода-вывода элементов множества следует использовать вспомогательные переменные. В то же время можно использовать множества как элементы типизированных файлов.
Действия над множествами
Объединение, пересечение и разность множеств
Над множествами выполнимы объединение (+), пересечение (*) и разность (-).
Объединение двух множеств A и B (A + B) – это новое множество, состоящее из элементов, принадлежащих множеству A или B, либо тому и другому одновременно.
var
chs1, chs2, chs3: setofchar;
begin
chs1 := [a, b, d];
chs2 := [m, d, e];
chs3 := chs1 + chs2 + [k, n];
end.
Результат: chs3 = [a, b, d, m, e, k, n].
Пересечение двух множеств A и B (A * B) – это множество, состоящее из элементов, одновременно принадлежащих множествам A и B.
chs3 := chs1 * chs2;
Результат: chs3 = [d].
Разность двух множеств A и B (A – B) – это новое множество, состоящее из элементов множества A, не вошедших в множество B.
chs1 := [a, e, t];
chs2 := chs1 – [e] { [a, t] }
chs3 := [m, n, t] – chs2 { [m, n] }
Манипулируя операциями над множествами, можно добавлять элементы к множествам или удалять их.
Для вставки и удаления элементов при работе с множествами в Pascal введены две процедуры:
include (имя_множества, элемент)
exclude (имя_множества, элемент)
Первая из них позволяет выполнить добавление одного элемента в указанное множество, а вторая удалить. Например:
include (chs1, g); { аналогично chs1 + [g] }
exclude (chs2, a); { аналогично chs2 - [a] }
Другие операции над множествами
Над множествами можно выполнять четыре операции сравнения: =, <>, >=, <=.
Два множества A и B равны (A = B), если каждый элемент множества A является элементом множества B и наоборот.
Два множества A и B не равны (A <> B), если они отличаются хотя бы одним элементом.
Множество A является подмножеством множества B (A <= B, или B >= A), если каждый элемент из A присутствует в B.
Имеется также возможность выяснить, принадлежит ли данный элемент некоторому множеству. Для этого служит операция in. Пусть A – множество элементов некоторого базового типа, а x – переменная (константа, выражение) этого типа. Тогда выражение x in A истинно, если значение x является элементом множества A.
Все операции сравнения множеств, а также операция in возвращают логическое значение true или false.


4. – 19 Программа сложной структуры. Понятие подпрограммы: процедуры и функции. Область действия переменных при использовании подпрограмм. Локальные и глобальные переменные.
5. Описание процедуры и функции. Особенности вызова процедур и функций. Формальные и фактические параметры. Примеры.

Подпрограмма - это отдельная функционально независимая часть программы.
Подпрограммы решают три важные задачи:
• избавляют от необходимости многократно повторять в тексте программы аналогичные фрагменты;
• улучшают структуру программы, облегчая ее понимание;
• повышают устойчивость к ошибкам программирования и непредвиденным последствиям при модификациях программы.
Очень важно понимать, что в подпрограмму может выделяться любой законченный фрагмент программы. В качестве ориентиров просмотрите следующие рекомендации:
1. Когда Вы несколько раз перепишете в программе одну и ту же последовательность команд, необходимость введения подпрограммы приобретает характер острой внутренней потребности.
2. Иногда слишком много мелочей заслоняют главное. Полезно убрать в подпрограмму подробности, скрывающие смысл основной программы.
3. Полезно разбить длинную программу на составные части - просто как книгу разбивают на главы. При этом основная программа становится похожей на оглавление.
4. Бывают сложные частные алгоритмы. Полезно отладить их отдельно в небольших тестирующих программах. Включение отлаженных алгоритмов в основную программу будет легким, если они оформлены как подпрограммы.
5. Все, что Вы сделали хорошо в одной программе, Вам захочется перенести в новые. Для повторного использования таких частей лучше сразу выделять в программе полезные алгоритмы в отдельные подпрограммы.
Подпрограммы могут быть стандартными, т.е. определенными системой, и собственными, т.е. определенными программистом.
Стандартная подпрограмма (процедура или функция) - подпрограмма, включенная в библиотеку программ, доступ к которой обеспечивается средствами языка программирования. Вызывается подпрограмма по имени с заданием фактических параметров. Типы фактических параметров должны соответствовать типам формальных параметров, указанным при описании данной процедуры в библиотечке процедур и функций.
Из набора стандартных процедур и функций по обработке одного типа информации составляются модули. Каждый модуль имеет своё имя (мы уже хорошо знакомы с модулями Crt, Graph). Доступ к процедурам и функциям модуля осуществляется при подключении этого модуля (Uses Crt, Graph).
Help содержит подробные описания предусмотренных средой программирования процедур и функций. Для вызова подсказки при работе со стандартными процедурами и функциями нужно поставить на имя подпрограммы курсор и нажать клавиши <Ctrl+F1>. Справочная информация о процедурах и функциях в Help имеет стандартную структуру.
Задание. Вызовите помощь по функции Cos и рассмотрите предоставленную информацию.
Сначала идет краткое описание подпрограммы (в одну фразу). Далее под словом Declaration (Объявление) следует интерфейсная часть процедуры или функции, которая необходима для определения типов фактических параметров. Далее под словом Target приводятся платформы, на которых может использоваться подпрограмма: Windows, real (реальный режим DOS), protected (защищенный режим DOS). После слова Remarks следуют заметки, содержащие необходимые детали использования. В разделе See Also приведены имена подпрограмм, связанных с данной по смыслу или по совместному применению. Если перемещать курсор по этим именам (они выделяются подсветкой), то, выбрав одно из них (нажав клавишу <Enter>), можно получить справку по следующей подпрограмме. Каждая процедура и функция сопровождается примером применения, переключение к которому дает последняя строка справочной информации. Любой текст из Help может быть скопирован в редактируемый файл обычными приемами копирования через буфер. Копирование примеров или заголовков функций может значительно облегчить работу.
Существует другой способ получения сведений о процедурах и функциях. Для этого нужно использовать пункт меню Help/Reserved words (зарезервированные слова) или Help/Standard units (стандартные модули).
Задание. Рассмотрите список процедур и функций, выберите какие-либо из них и ознакомьтесь со справочной информацией.
В стандартных модулях содержится большое количество подпрограмм, но невозможно создать модуль, который бы содержал все нужные программисту подпрограммы. Поэтому большую роль играют собственные подпрограммы, которые создает программист для решения конкретной задачи.
Существует два способа объединения программ и подпрограмм пользователя:
1. Текст подпрограммы может быть приведен в разделе описания использующей их программы.
2. Подпрограммы группируются в отдельных файлах, имеющих специальную структуру - модулях. Для того чтобы основная программа могла использовать модуль, он должен быть подключен к основной программе.
Первый способ применяется тогда, когда программа в целом не очень большая, а ее подпрограммы, скорее всего, не будут использоваться в других программах.
Структура текста подпрограммы соответствует структуре текста основной программы за двумя исключениями:
• подпрограмма начинается с заголовка, содержащего имя подпрограммы, передаваемые в нее и возвращаемые от нее параметры, т.е. запись заголовка подпрограммы отличается от заголовка программы;
• подпрограмма кончается не точкой, а точкой с запятой.
Вызов подпрограммы происходит при каждом употреблении ее имени в основной (или вызывающей) программе. При вызове подпрограммы выполнение основной программы приостанавливается, и управление передается в подпрограмму, где выполняются команды, заданные в ней. Подпрограмма завершается, если выполнены все ее операторы до завершающего слова End или по специальной команде выхода из подпрограммы Exit. По окончании работы подпрограммы управление возвращается основной программе, а именно, первой команде, следующей за обращением к этой подпрограмме.
В языке Pascal определяются два типа подпрограмм - процедуры и функции. Основное различие между процедурой и функцией состоит в том, что процедура только выполняет какую-либо законченную последовательность действий, не возвращая результата работы в основную программу, а функция и выполняет действия, и возвращает результат.
Например, вызов функции
M:= MIN (X, Y)
вернет в основную программу значение наименьшего из двух чисел и это значение будет присвоено переменной M.
Все переменные, которые использует подпрограмма, могут быть либо глобальными, либо локальными.
Определение. Глобальными называются переменные, объявленные в основной программе и доступные как программе, так и всем ее подпрограммам.
Определение. Локальными называются переменные, объявленные внутри подпрограммы и доступные только ей самой.
Обмен информацией между основной программой и подпрограммой может осуществляться только с помощью глобальных переменных и с помощью параметров подпрограммы.
Подпрограмма может использовать любые глобальные переменные кроме тех, которые имеют те же имена, что и ее локальные переменные. Если в подпрограмме описана локальная переменная, имя которой совпадает с именем некоторой глобальной переменной, то данная глобальная переменная становится недоступной в этой подпрограмме, и при указании идентификатора переменной произойдет обращение к локальной переменой подпрограммы, а не одноименной глобальной переменной. Память для локальных (т.е. описанных в подпрограмме) переменных выделяется на время исполнения данной подпрограммы в специальной области, называемой стеком. При завершении работы подпрограммы память освобождается, поэтому все внутренние результаты работы подпрограммы не сохраняются от одного обращения к другому.
Если говорить о плюсах использования подпрограмм, то можно назвать следующие:
1. Программы с использованием подпрограмм позволяют реализовать один из самых прогрессивных методов программирования - структурное программирование.
2. Программа становится более читаемой.
3. Происходит экономия памяти, которая получается из-за того, что память для хранения переменных, используемых в подпрограммах, выделяется только на время работы подпрограммы.
В языке Паскаль выделяют два вида подпрограмм: процедуры (Procedure) и функции (Function). Любая программа может содержать несколько процедур и функций. Структура любой подпрограммы аналогична структуре всей программы.
Подпрограмма должна быть описана до того, как будет использована в программе или другой подпрограмме.
Процедуры и функции объявляются в разделе описания вслед за разделом переменных.
Общая структура программы выглядит так:
Рrogram hh;
Label; {описание меток}
Const; {описание констант}
Type; {описание типов}
Var; {описание переменных}
Procedure; {описание процедур}
Function; {описание функций}
Begin
. . .
. . .
end.
Выполнение программы начинается с операторов основной программы. При необходимости вызывается подпрограмма, и начинают действовать её операторы. Затем управление возвращается в основную программу, которая и продолжает выполняться.
Обращение к подпрограмме - переход к выполнению подпрограммы с заданием информации, необходимой для ее выполнения и возврата.
Подпрограмма вызывается по своему имени с указанием необходимых параметров.
На этом занятии рассмотрим примеры организации наиболее простого вызова подпрограмм.
Задание. Рассмотрите решение предложенных задач, наберите программы на компьютере, проверьте их работоспособность, внесите свои изменения и дополните своими комментариями.
Задача 1. Написать программу, состоящую из трех подпрограмм и основной программы. Подпрограммы должны организовывать ввод чисел, вычисление их суммы и вывод результата.
Program AkulovE;
Uses
Crt;
Var
x, y : LongInt;
Procedure Input;
Begin
TextColor(12);
writeln(По вызову активизировалась процедура "Input",#10);
TextColor(7);
writeln(Введите два числа через пробел - );
readln(x, y);
End;
{ - - - - - - - - - - - - - - - - - - - -}
Procedure Summa;
Begin
TextColor(14);
writeln(Для сложения подключилась процедура "Summa",#10);
x:=x+y;
End;
{ - - - - - - - - - - - - - - - - - - - -}
Procedure Output;
Begin
TextColor(10);
writeln(Заключительная часть. Процедура "Output",#10,#13);
TextColor(7);
writeln(Ихсумма - ,x);
End;
{ - - - - - - - - - - - - - - - - - - - -}
Begin
ClrScr;
Input;
Summa;
Output;
readln;
End.
Задача 2. Найти среднее арифметическое двух чисел.
Program Fadeev;
Uses
Crt;
Var
A, B : integer;
Rez :real;
{ - - - - - - - - - - - - - - - - - - - -}
Function SredArif(A, B:integer):real;
Begin
SredArif:=(A+B)/2;
End;
{ - - - - - - - - - - - - - - - - - - - -}
Begin
ClrScr;
write(Введите два числа );
readln(A,B);
Rez:=SredArif(A,B);
write(Cреднее арифметическое этих чисел равно ,Rez:5:3);
readln;
End.





6. Рекурсии. Примеры.

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

Построим последовательность чисел следующим образом: возьмем целое число i>1. Следующий член последовательности равен i/2, если i четное, и 3 i+1, если i нечетное. Если i=1, то последовательность останавливается.
Математически конечность последовательности независимо от начального i не доказана, но на практике последовательность останавливается всегда.
Применение рекурсии позволило решить задачу без использования циклов, как в основной программе, так и в процедуре.

Program Arsac;
Var first: word;
Procedure posledov (i: word);
Begin
Writeln (i);
If i=1 then exit;
If odd(i) then posledov(3*i+1) else posledov(i div 2);
End;
Begin
Write (‘ введитепервоезначение ’); readln (first);
Posledov (first);
Readln ;
End.

Это может показаться удивительным, но самовызов процедуры ничем не отличается от вызова другой процедуры. Что происходит, если одна процедура вызывает другую? В общих чертах следующее:
• в памяти размещаются параметры, передаваемые процедуре (но не параметры-переменные!);
• в другом месте памяти сохраняются значения внутренних переменных вызывающей процедуры;
• запоминается адрес возврата в вызывающую процедуру;
• управление передается вызванной процедуре.
Если процедуру вызвать повторно из другой процедуры или из нее самой, будет выполняться тот же код, но работать он будет с другими значениями параметров и внутренних переменных. Это и дает возможность рекурсии.
Пусть рекурсивная процедура Power( X, N, Y) возводит число X в степень N и возвращает результат Y .

Procedure Power (X: real; N: integer; var Y: real);
Begin
If N=0 then
Y:= 1
Else Begin Power(X, N-1,Y);
Y:= Y*X;
End ;
End ;




Пример рекурсивной программы вычисления функции
Program primer;
Uses crt;
Var
N, a: integer;
Function f(n:integer):integer;
Begin
If n =1 then
f :=1 {условие завершения рекурсии}
Else
Begin
If odd ( n ){проверка на нечетность числа}
then begin
n:= n div 2;
f:=f(n)+f(n+1)
end
else begin
n:= n div 2;
f:=f(n)
end;
end ;
end ;
begin {начало основной программы}
clrscr;
write(‘ Введите число – ‘);
readln(n);
a:=f(n);
write(‘ результат – ‘, a);
end.

7. Файлы. Файловый тип и файловые переменные. Типизированные файлы. Процедуры работы с типизированными файлами. Примеры.

Файл представляет собой именованную последовательность однотипных элементов, размещенных на внешнем устройстве. Для выполнения операций с конкретным файлом в программе обычно используется так называемая файловая переменная или логический файл. В зависимости от типа элементов различают текстовые, типизированные и нетипизированные файлы.
• Текстовый файл можно рассматривать как последовательность символов, разбитую на строки длиной от 0 до 256 символов. Текстовый файл - это файл, компонентами которого являются символьные строки переменной длины, заканчивающиеся специальным маркером конца строки Для описания используется стандартный тип Text:
var
F: text; {F - файловая переменная}

• К типизированным файлам относятся файлы строго определенного типа. Чаще всего это файлы, состоящие из записей. Они применяются для создания различных баз данных.

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

type
FileRec = record
end;
var F : file of FileRec;

• Нетипизированными называют файлы, объявленные без указания типа его компонентов. Операции чтения и записи с такими файлами осуществляются блоками. Отсутствие типа компонента делает эти файлы совместимыми с любыми другими, а выполнение ввода/вывода блоками позволяет организовать высокоскоростной обмен данными между диском и памятью. Нетипизированные файлы, как и типизированные, допускают организацию прямого доступа.
Для определения в программе нетипизированного файла служит зарезервированное слово File:
var UntypedFile : File;

Процедуры работы с типизированными файлами

1. AssignFile(F,’test.dat’) — связывает файловую переменную с именем файла, параметры передаваемые — файловая переменная и путь к файлу
2. Rewrite(F) — создает файл, параметры — файловая переменная, необязательные — режим создания
3. Reset(F) — открывает файл, то есть подрузумевается в том, что мы как бы ставим файл в режим открытия, чтения (в общем если файл имеется на диске или еще каком-то носителе и нам из него необходимо прочитать информацию, то тут без этой функции не обойтись).
4. Seek (F,n) — устанавливает указатель в файле на нужную компоненту, параметры — файловая переменная, номер компоненты на которую необходимо переместиться.
5. Write(F,Buf) — записывает компоненту в файл, параметры — файловая переменная, запись с данными
6. Read(F,Buf) — считывает компоненту из файла, на которой стоит указатель (по умолчанию на первой), параметры — файловая переменная и запись, в которую необходимо считать данные
7. EOF(F) — определяет достигнут ли конец файла (указатель конца файла), параметры — файловая переменная
8. Truncate(F) — удаляет компоненту в файле, параметры — файловая переменная, перед этим необходимо установить указатель на компоненту, которую необходимо удалить
9. FileSize(F) — определяет количество компонентов в файле, параметры — файловая переменная, возвращает целочисленный тип
10. CloseFile(F) — закрывает файл, параметры — файловая переменная.
Пример :Составить программу, которая переписывает существующий файл, заменяя все латинские буквы на заглавные.

Рrogram Writing;
Var
FileName : string; {строка, содержащаяимяфайла}
FVar : file of char; {переменнаяфайловоготипа}
Index : integer;
Letter : char; {читаемый из файла символ}
Begin
write(Enter filename: ); {предложениеввестиимяфайла}
readln (FileName); {вводименифайла}
assign (FVar,FileName); {связьименифайлаипеременной}
{$I-} {отключен контроль ввода/вывода}
reset (FVar); {открытие файла для чтения и записи}
{$I+} {включен контроль ввода/вывода}
if IOResult <> 0 {выход, если файл не открыт}
then
begin
writeln (Неоткрытфайл , FileName);
Halt
end;
while not EOF (FVar) do {циклдоконцафайла}
begin
read (FVar, Letter); {чтениесимволаизфайла}
Letter:=Upcase(Letter); (преобразованиебукв)
Seek(FVar,FilePos(FVar)-1); {перемещение указателя назад на 1 позицию}
write(FVar,Letter); {запись преобразованной буквы}
end; {конец цикла}
close(FVar) {закрыть файл}
End.

8. Сущность объектно-ориентированного программирования. Понятие класса, объекта, свойства и метода. Примеры.

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

С точки зрения языка программирования класс объектов можно рассматривать как тип данного, а отдельный объект - как данное этого типа. Определение программистом собственных классов объектов для конкретного набора задач должно позволить описывать отдельные задачи в терминах самого класса задач (при соответствующем выборе имен типов и имен объектов, их параметров и выполняемых действий).

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

Класс – это абстрактный тип данных. С помощью класса описывается некоторая сущность (ее характеристики и возможные действия). Например, класс может описывать студента, автомобиль и т.д.
Описав класс, мы можем создать его экземпляр – объект. Объект – это уже конкретный представитель класса.

Класс в ООП - это абстрактный тип данных, который включает в себя не только данные, но и функции и процедуры.

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


После того, как Вы объявили состав класса, необходимо определить (описать), что делает каждая функция-член (метод).
Существует 2 способа включения метода в класс:
1. Определение метода при описании класса.
2. Объявление метода при описании, а его описание - при вызове.
Методы, определенные внутри класса, являются неявно встроенными.

Пример.
class A
{
int x, y;
int sum ( ) { return (x + y) ; }
} ;

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

Пример.
Class B
{
int x, y;
int sum ( )
} ;
int B::sum ( ) { return (x + y) ; }

Также как и структуры, классы можно задавать либо статически, либо динамически.
Например,
статически - Toplist foo;
динамически - Toplist *bar ; bar=new Toplist;

Для статических и динамических классов применимы те же правила и принципы, что и для статических и динамических переменных.

Объект - экземпляр класса.




Свойства объекта
Псевдополя, доступные для чтения и/или записи. Свойства внешне выглядят как поля и используются аналогично доступным полям (с некоторыми исключениями), однако фактически при обращении к ним происходит вызов методов доступа.
Таким образом, свойства можно рассматривать как «умные» поля данных, сопровождающие доступ к внутренним данным объекта какими-либо дополнительными действиями (например, когда изменение координаты объекта сопровождается его перерисовкой на новом месте).
Наследование — важный механизм объектно-ориентированного подхода, позволяющий расширить и/или изменить структуру уже существующего (родительского) класса, путём написания нового класса (потомка), который полностью наследует все свойства и методы и, плюс, добавляет что-то своё. Далее можно начинать создавать и использовать в программе новые объекты с расширенными возможностями.
Пример.
Type tperson=record ,где record –объект

Важные понятия и термины
 Атрибут — это характеристика, назначенная элементу класса (например, свойству или методу) в определении класса. Атрибуты часто используются для определения того, будет ли свойство (или метод) доступно для кода в других частях программы. Например, private (закрытый) и public (открытый) — это атрибуты. Закрытый метод может вызываться только кодом внутри класса, а открытый метод может вызываться любым кодом в программе.
 Класс — это определение структуры и поведения объектов определенного типа (как шаблон или схема объектов для этого типа данных).
 Иерархия классов — это структура многочисленных связанных классов, определяющая, какие классы наследуют функции от других классов.
 Конструктор — это особый метод, определяемый в классе, который вызывается при создании экземпляра класса. Конструкторы обычно используются для определения значений по умолчанию или для выполнения других операций по настройке объекта.
 Тип данных — это тип информации, который может хранить та или иная переменная. Как правило, термин тип данных имеет то же значение, что и класс.
 Оператор «точка» — это знак точки (.), который в ActionScript (и многих других языках программирования) служит для указания того, что имя относится к дочернему элементу объекта (например, к свойству или методу). Например, в выраженииmyObject.myProperty оператор «точка» указывает на то, что термин myProperty ссылается на какое-то значение, являющееся элементом объекта с именем myObject.
 Перечисление — это набор связанных констант, сгруппированных вместе для удобства в качестве свойств одного класса.
 Наследование — это механизм ООП, позволяющий определению одного класса включать все функции определения другого класса (и, как правило, расширять эти функции).
 Экземпляр — фактический объект, созданный в программе.
 Пространство имен — это, главным образом, пользовательский атрибут, обеспечивающий более полный контроль над тем, какой код может получить доступ к другому коду.

9. Принципы объектно-ориентированного программирования.

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

Абстрагирование - способо выделит набор наиболее значемых характеристик объекта исключая из рассмотрения незначимые.
Инкапсуляция- св-ва системы позволяющая объединить дынные и методы работающие с ними в классе и скрыть детали реализации их от пользователя.(Не разрывно связана с понятием интерфейс, все что входит в интерфейс инкапсулируется в классе.
Наследование - свойство системы позволяющее описать новый класс на основе уже существующего с частичной или полностью заимствующийся функциональностью. Класс от которого производится наследование называется родительским, новый - как потомок или дочерним классом.
Полиморфизм- свойство системы с одинаковым интерфейсом без информации о типе и внешней структуре объекта. Возможность замещения методов родителя методами потомка.
Кроме выше перечисленных методов существуют еще ряд свойств характерных для ООП:
Модульность - принцип разработки программной системы в виде реализации ее программных частей.
Иерархия- упорядоченная система абстракций. Принцип иерархии предполагает использование иерархии при разработки программ.системы.
Параллелизм - это свойство нескольких абстракций одновременно выполняемые определенные операции.
Устойчивость - свойство абстракции существовать во времени независимо от процесса, породившего данный программный объект, и/или в пространстве, перемещаясь из адресного пространства, в котором он был создан.


10. Интегрированная среда разработки приложений Delphi: общее описание среды. Библиотека компонентов Delphi – VCL. Иерархия классов VCL.

Delphi – это потомок среды программирования TurboPascal. Название среды произошло от названия города в Древней Греции, где находился знаменитый Дельфийский оракул (храм Аполлона в городе Дельфы, жрецы которого занимались предсказаниями).
Система визуального объектно-ориентированного проектирования Delphi позволяет:
1. Создавать законченные приложения для Windows самой различной направленности.
2. Быстро создавать профессионально выглядящий оконный интерфейс для любых приложений; интерфейс удовлетворяет всем требованиям Windows и автоматически настраивается на ту систему, которая установлена, поскольку использует функции, процедуры и библиотеки Windows.
3. Создавать свои динамически присоединяемые библиотеки компонентов, форм, функций, которые потом можно использовать из других языков программирования.
4. Создавать мощные системы работы с базами данных любых типов.
5. Формировать и печатать сложные отчеты, включающие таблицы, графики и т.п.
6. Создавать справочные системы, как для своих приложений, так и для любых других.
7. Создавать профессиональные программы установки для приложений Windows, учитывающие всю специфику и все требования операционной системы.
Delphi – быстро развивающаяся система. Первая версия Delphi была выпущена в феврале 1995 года, в 1996 году вышла вторая версия, 1997 – третья, 1998 – четвертая, 1999 – пятая, 2001 – шестая. Все версии, начиная с Delphi 2.0, рассчитаны на разработку 32-разрядных приложений, т.е. приложений для операционных систем Windows 95/98, NTи т.д. В 2002 году вышла седьмая версия, основным нововведением в которой были Интернет-технологии.
Общее описание среды.
Интегрированная среда разработки Delphi – это среда, в которой есть все необходимое для проектирования, запуска и тестирования создаваемых приложений. Большинство версий Delphi выпускается в нескольких вариантах: а) стандартная, б) профессиональная версия, в) разработка баз данных предметных областей. Эти варианты различаются, в основном разным уровнем доступа к системам управления базами данных. Последние два варианта являются наиболее мощными в этом отношении. Библиотеки компонентов в различных вариантах практически одинаковы.
1) Верхней части окна среды отображается полоса главного меню . Назначение каждого пункта меню можно уточнить в справочной системе Delphi. Для получения справки следует выбрать интересующий пункт меню и нажать клавишу F1. Выбор команды меню выполняется любым из стандартных способов: F10, Alt+горячая клавиша или щелчком мыши на нужном пункте меню.
Назначение команд меню представлены в таблице:
Раздел меню Назначение
1) Меню File (Файл) Разделы меню позволяют создавать новый проект, новую форму, открыть ранее созданный проект или форму, сохранить проекты или форму в файлах с заданными именами.
2) Меню Edit (Правка) Разделы этого меню позволяют выполнять обычные для приложений Windows операции с буфером обмена, а также дают возможность выравнивать группы размещенных на форме компонентов по размерам и местоположению.
3) Меню Search (Поиск) Разделы этого меню позволяют осуществлять поиск фрагментов текста, ошибок, объектов, модулей, переменных и символов в редакторе кода.
4) Меню View (Вид) Разделы этого меню позволяют вывести на экран или скрыть различные элементы среды проектирования и открыть окна, связанные с интегрированным отладчиком.
5) Меню Project (Проект) Разделы меню позволяют добавлять и удалять из проекта формы, задавать опции проекта, компилировать проект без его выполнения, дать информацию о размерах приложения.
6) Меню Run (Выполнить) Предоставляет возможность выполнять проект в нормальном или отладочном режимах, по шагам, останавливаясь в указанных точках, просматривая значения переменных и т.д.
7) Меню Component (Компонент) Содержит раскрывающееся меню, которое позволяет работать с компонентами: создавать новые компоненты, изменять палитру компонентов и т.п.
8) Меню Database (База данных) Раздел меню позволяет использовать инструментарий для работы с базами данных.
9) Меню Tools (Сервис) Включает ряд разделов, позволяющих выполнять различные вспомогательные программы: редактор изображений, программы, конфигурирующие базы данных и сети и т.п.
10) Меню Windows (Окно) Содержит список открытых окон среды и предоставляет возможность перехода из одного окна в другое.
11) Меню Help (Помощь) Содержит разделы, помогающие работать со справочной системой среды программирования Delphi.
2) Ниже полосы главного меню расположены две инструментальные панели . Левая панель(состоящая, в свою очередь, из трех панелей) содержит два ряда кнопок, дублирующих некоторые наиболее часто используемые команды меню (открыть, сохранить, сохранить все и т.д.). Правая панельсодержит панель библиотеки визуальных компонентов (или палитра). Палитра компонентов содержит ряд страниц, закладки которых видны в ее верхней части. Страницы сгруппированы в соответствии с их смыслом и назначением. Поскольку число предоставляемых компонентов растет от версии к версии, то остановимся на основных (12 страниц).
Основные Палитры компонентов представлены в таблице:
Палитра компонентов Назначение
1. Палитра компонентов Standard (Стандартная) Большинство компонентов на этой странице являются аналогами экранных элементов операционной системы Windows: меню, кнопки, полосы прокрутки, панели и т.п. Имена компонентов можно узнать из всплывающей подсказки. Назначение компонентов можно уточнить, используя систему контекстной справки Delphi.
2. Палитра компонентов Additional (Дополнительная) Содержит более развитые компоненты: а) воспроизведение звука, музыки и видео; б) отображение графической информации.
3. Палитра компонентов System (Системная) Предоставляет возможность объединять отдельные элементы, такие как списки каталогов и файлов, а также генерировать события через определенные промежутки времени.
4. Палитра компонентов Win32 Содержит компоненты, позволяющие созданным программам использовать интерфейс Windows.
5. Палитра компонентов Dialogs (Диалоговая) Содержит стандартные диалоговые окна для операций над файлами, поиска и замены текста, выбор шрифтов, цветов и т.д.
6. Палитра компонентов DataAccess, DataControls (Сервис баз данных) Использует механизм баз данных для организации доступа к файлам баз данных различных форматов.
7. Палитра компонентов QReport (Отчеты) Предоставляет компоненты для визуального проектирования отчетов баз данных.
8. Палитра компонентов Servers (Сервис) Предоставляет компоненты-наследники для доступа ко всем серверным объектам MicrosoftOffice.
9. Палитра компонентов Samples (Примеры) Содержит компоненты-примеры, которые можно добавлять в собственные приложения.
10. Палитра компонентов Internet Предоставляет компоненты для разработки приложений, позволяющих создавать HTML файлы непосредственно из файлов баз данных и других типов, взаимодействующих с другими приложениями для Интернета.
3) Правее полосы главного меню располагается еще одна небольшая инструментальная панель, содержащая раскрывающийся список и две кнопки. Эта панель служит для сохранения и выбора различных конфигураций окна среды, которые можно создавать и запоминать.
4) Под палитрой компонентов располагается окно формы с размещенными на ней компонентами. Форма является основой почти всех приложений Delphi. Форму можно понимать как типичное окно Windows. Она обладает теми же свойствами, что и другие окна. Во время проектирования форма покрыта сеткой из точек. В узлах этой сетки размещаются те компоненты, которые помещены на форму. Во время выполнения приложения эта сетка не видна.
5) В основном поле окна слева находится окно Инспектора объектов , с помощью которого в дальнейшем можно задавать свойства компонентов и обработчики событий. Инспектор объектов состоит из двух страниц, каждую из которых можно использовать для определения поведения активного компонента. Первая страница – это Свойства, вторая – События.
Рассмотрим некоторые свойства любого компонента :
Свойство Назначение
Caption (надпись) Название компонента
Color Цвет поверхности компонента
Font Color Цвет шрифта
Font Height Высота шрифта
Font Name Имя шрифта
Font Size Размер шрифта
StylefsBold Стиль надписи на компоненте – Жирный
Style fsItalic Стиль надписи на компоненте – курсив
Style fsUnderline Стиль надписи на компоненте – подчеркивание
Style fsStrikeOut Стиль надписи на компоненте – зачеркивание
Каждый компонент имеет свой набор свойств, который соответствует назначению этого компонента.
Страница Событий – вторая часть Инспектора объектов. На ней указаны все события, на которые может реагировать выбранный объект.
6) Одним из наиболее важных элементов среды Delphi является окно Редактора кода . Оно располагается ниже окна формы, обычно при первом взгляде на экран невидимо, т. к. его размер равен размеру формы и окно Редактора кода практически полностью перекрывается окном формы. Редактор кода является полноценным программным редактором. В заголовке окна редактора кода отображается имя текущего файла, с текстом которого производится работа (стандартное имя – Main.pas). В нижней части окна Редактора кода располагается строка состояния. В самой левой ее позиции отображается позиция курсора: номер строки и колонки.
7) Выше окна Инспектора объектов расположено окно Дерево объектов , которое отображает структуру компонентов приложения с точки зрения их принадлежности друг к другу.
Примечание: Страница событий связана с Редактором кода, если дважды щелкнуть мышью по правой стороне какого либо пункта, то соответствующий данному событию код будет автоматически помещен в окно Редактора кода.

Библиотека визуальных компонентов (Visual Component Library, сокращенно — VCL) содержит большое количество классов, предназначенных для быстрой разработки приложений. Библиотека написана на Object Pascal и непосредственно связана с интегрированной средой разработки приложений Delphi. Несмотря на название, в VCL содержатся главным образом невизуальные компоненты, однако имеются и визуальные, а также другие классы, начиная с абстрактного класса TObject. При этом все компоненты являются классами, но не все классы являются компонентами.
В Delphi 7 также имеется возможность использовать библиотеку CLX (межплатформенный вариант библиотеки VCL) для разработки приложений под Windows и Linux.
Все классы VCL расположены на определенном уровне иерархии и образуют дерево (иерархию) классов. Знание происхождения объекта оказывает значительную помощь при его изучении, т. к. потомок наследует все элементы объекта-родителя. Так, если свойство caption принадлежит классу TControl, то это свойство будет и у его потомков, например, у классов TButton и TCheckBox, и у компонентов— кнопки Button и флажка CheckBox соответственно. Фрагмент иерархии классов с важнейшими классами показан ниже на схеме.

Кроме иерархии классов, большим подспорьем в изучении системы программирования являются исходные тексты модулей, которые находятся в каталоге source главного каталога Delphi.
Класс TObject — общий предок всех классов Object Pascal — находится в корне иерархии. Этот класс является абстрактным и реализует наиболее общие для всех классов-потомков методы, важнейшими из которых являются:
• Create (создание объекта);
• Destroy (удаление объекта);
• Free (удаление объекта, созданного методом create, при этом вызывается и метод Destroy).
Большинство этих методов переопределяются в классах-потомках. Дадим краткую характеристику важнейшим классам-потомкам TPersistent, TComponent и TControl, к которым относится большинство общих свойств, методов и событий и которые, в свою очередь, также порождают множество классов.
Класс TPersistent является абстрактным классом для тех объектов, свойства которых загружаются из потока и сохраняются в потоке. Механизм потоков используется для работы с памятью (обычно дисковой или оперативной). В дополнение к методам класса TObject класс TPersistent имеет метод Assign, позволяющий передавать поля и свойства одного объекта другому.
Класс TComponent является базовым для всех компонентов и в дополнение к методам своих предков предоставляет средства, благодаря которым компоненты способны владеть другими компонентами. В результате при помещении в форму любой компонент будет принадлежать другому компоненту (чаще всего форме). При создании компонента он обеспечивает автоматическое создание всех принадлежащих ему компонентов, а при удалении этого компонента все принадлежащие ему компоненты также автоматически удаляются.
Основные свойства TComponent.
• Components (список принадлежащих компонентов);
• Сomponentcount (число принадлежащих компонентов);
• Component index (номер компонента в списке принадлежащих компонентов);
• Сomponentstate (состояние текущего компонента);
• Name (имя компонента);
• Owner (владелец компонента);
• Tag (целое значение, хранимое вместе с компонентом).
Основные методы класса TComponent:
• DestroyComponents (разрушает все принадлежащие компоненты);
• Destroying (уведомляет принадлежащий компонент о его разрушении);
• FindComponent (находит компонент в списке Components).
От класса TComponent происходят визуальные и невизуальные компоненты. Многие невизуальные компоненты порождены непосредственно от класса TComponent, например, таймер (Timer).
Компонент Timer позволяет реализовать выполнение действий через определенные интервалы времени. Для этого используется событие onTimer типа TNotifyEvent, генерируемое по истечении заданного интервала времени. Интервал времени в миллисекундах задается свойством Interval типа Cardinal и по умолчанию равен 1000, что соответствует тиканью таймера через 1 секунду. Если установить интервал равным нулю, то таймер остановится и не будет генерировать события onTimer. Остановить таймер также можно, присвоив значение False свойству Enabled.
Если система занята выполнением более важных задач, чем отслеживание хода таймера, то интервал между соседними тиканьями таймера может увеличиваться. Это происходит, например, при считывании с диска больших файлов или при выполнении длинного цикла.
Класс TControl является базовым классом для визуальных компонентов (элементов управления) и обеспечивает основные средства для их функционирования, в том числе прорисовку на экране. Все визуальные компоненты делятся на оконные и графические, происходящие, соответственно, от классовTWinControl и TGraphicControl.
Таковы наиболее общие классы библиотеки визуальных компонентов.



25. Проект как основа разработки приложения. Состав проекта. Структура программы Delphi.

Любая программа в Delphi состоит из файла проекта (файл с расширением dpr) и одного или нескольких модулей (файлы с расширениями pas). Каждый из таких файлов описывает программную единицу Object Pascal.
Структура проекта
Файл проекта представляет собой программу, написанную на языке Object Pascal и предназначенную для обработки компилятором. Эта программа автоматически создается Delphi и содержит лишь несколько строк. Чтобы увидеть их, запустите Delphi и щелкните по опции Project / View Source главного меню [ В предыдущих версиях Delphi для просмотра кода проекта используйте опцию View / project Source. ]. Delphi покажет окно кода с закладкой Project1, содержащее такой текст:
program Projecti;
uses
Forms, Unit1 in Unit1.pas {fmExample};
{$R *.RES}
begin
Application.Initialize;
Application.CreateForm(TfmExample, fmExample);
Application.Run;
end.
В окне кода жирным шрифтом выделяются так называемые зарезервированные слова, а курсивом - комментарии (так же выделяются зарезервированные слова и комментарии в книге). Как видим, текст программы начинается зарезервированным словом program и заканчивается словом end с точкой за ним. Замечу, что сочетание end со следующей за ней точкой называется терминатором программной единицы: как только в тексте программы встретится такой терминатор, компилятор прекращает анализ программы и игнорирует оставшуюся часть текста.
Зарезервированные слова играют важную роль в Object Pascal, придавая программе в целом свойство текста, написанного на почти естественном английском языке. Каждое зарезервированное слово (а их в Object Pascal несколько десятков) несет в себе условное сообщение для компилятора, который анализирует текст программы так же, как читаем его и мы: слева направо и сверху вниз.
Комментарии, наоборот, ничего не значат для компилятора, и он их игнорирует. Комментарии важны для программиста, который с их помощью поясняет те или иные места программы. Наличие комментариев в тексте программы делает ее понятнее и позволяет легко вспомнить особенности реализации программы, которую вы написали несколько лет назад. В Object Pascal комментарием считается любая последовательность символов, заключенная в фигурные скобки. В приведенном выше тексте таких комментариев два, но строка
{$R *.RES}
на самом деле не является комментарием. Этот специальным образом написанный фрагмент кода называется директивой компилятора (в нашем случае - указание компилятору на необходимость подключения к программе так называемого файла ресурсов). Директивы начинаются символом $, который стоит сразу за открывающей фигурной скобкой.
Поскольку речь зашла о комментариях, замечу, что в Object Pascal в качестве ограничителей комментария могут также использоваться пары символов (*, *) и //. Скобки (*...*) используются подобно фигурным скобкам т. е. комментарием считается находящийся в них фрагмент текста, а символы // указывают компилятору, что комментарий располагается за ними и продолжается до конца текущей строки:
{Это комментарий}
(*Это тоже комментарий*)
//Все символы до конца этой строки составляют комментарий
Слово Program со следующим за ним именем программы и точкой с запятой образуют заголовок программы. За заголовком следует раздел описаний, в котором программист (или Delphi) описывает используемые в программе идентификаторы. Идентификаторы обозначают элементы программы, такие как типы, переменные, процедуры, функции (об элементах программы мы поговорим чуть позже). Здесь же с помощью предложения, которое начинается зарезервированным словом uses (использовать) программист сообщает компилятору о тех фрагментах программы (модулях), которые необходимо рассматривать как неотъемлемые составные части программы и которые располагаются в других файлах. Строки
uses
Forms, Unit1 in Unitl.pas {fmExample};
указывают, что помимо файла проекта в программе должны использоваться модули Forms И Unit1. модуль Forms является стандартным (т. е. уже известным Delphi), а модуль Unit1 - новым, ранее неизвестным, и

Delphi в этом случае указывает также имя файла с текстом модуля (in uniti.pas) и имя связанного с модулем файла описания формы {fmExample}.
Собственно тело программы начинается со слова begin (начать) и ограничивается терминатором end с точкой. Тело состоит из нескольких операторов языка Object Pascal. В каждом операторе реализуется некоторое действие - изменение значения переменной, анализ результата вычисления, обращение к подпрограмме и т. п. В теле нашей программы - три исполняемых оператора:
Application.Initialize;
Application.CreateForm(TfmExample, fmExample);
Application.Run;
Каждый из них реализует обращение к одному из методов объекта Application. Я вынужден забежать вперед и хотя бы кратко пояснить только, что введенные термины, которые определяют важные для Object Pascal понятия. Объектом называется специальным образом оформленный фрагмент программы, заключающий в себе данные и подпрограммы для их обработки. Данные называются полями объекта, а подпрограммы - его методами. Объект в целом предназначен для решения какой-либо конкретной задачи и воспринимается в программе как неделимое целое (иными словами, нельзя из объекта "выдернуть" отдельное поле или метод). Объекты играют чрезвычайно важную роль в современных языках программирования. Они придуманы для того, чтобы увеличить производительность труда программиста и одновременно повысить качество разрабатываемых им программ. Два главных свойства объекта - функциональность и неделимость - делают его самостоятельной или даже самодостаточной частью программы и позволяют легко переносить объект из одной программы в другую. Разработчики Delphi придумали для нас с вами сотни объектов, которые можно рассматривать как кирпичики, из которых программист строит многоэтажное здание программы. Такой принцип построения программ называется объектно-ориентированным программированием (ООП). В объекте Application собраны данные и подпрограммы, необходимые для нормального функционирования Windows-программы в целом. Delphi автоматически создает объект-программу Application для каждого нового проекта. Строка
Application.Initialize;
означаетобращениекметодуInitializeобъектаApplication. Прочитав эту строку, компилятор создаст код, который заставит процессор перейти к выполнению некоторого фрагмента программы, написанного для нас разработчиками Delphi. После выполнения этого фрагмента (программисты говорят: после выхода из подпрограммы) управление процессором перейдет к следующей строке программы, в которой вызывается метод CreateForm и т. д.
1. файл проекта (.dbr) это текстовый файл используется для хранения информации о формах и модулях. В нем содержатся операторы инициализации и запуска программы на выполнение.
2. файл модуля (.pas) соответствующий файл модуль для хранения кода.
3. файл формы (.dfm) – это двоичный файл, который создается для хранения информации о ваших формах и фреймах.
4. файл опций проекта (.dof) — в нем хранится установки опций проекта.
5. файл конфигурации проекта (.cfg) в нем хранятся установки проекта.
6. файл ресурсов (.res) содержит пиктограмму и прочие ресурсы.
7. файл группы файлов (.bpg) для создания групп файлов.
8. резервные копии (~dp,~df,~pa).
26 Форма (класс TForm). Создание и уничтожение формы. Визуализация формы. Атрибуты и стили формы
Формы имеют свои свойства, события и методы, при помощи которых Вы можете управлять видом и поведением формы. Форма, это обычный компонент Delphi, но в отличие от других, её нет на панели компонентов. Обычно форма создаётся при создании нового проекта (File | New Application). Вновь созданная форма будет главной формой приложения.
Дополнительные формы в проекте создаются через File | New Form. Так же существуют и другие способы создания форм, но здесь мы не будем рассматривать их...
Как и любой другой компонент (объект) форма имеет свои методы и реагирует на события. Давайте рассмотрим некоторые из этих событий...
Рождение формы в Delphi
OnCreate -> OnShow -> OnActivate -> OnPaint -> OnResize -> OnPaint ...
OnCreate Событие OnCreate возникает при создании TForm и только один раз. При создании формы (у каторой свойство Visible установлено в True), события произойдут в следующем порядке: OnCreate, OnShow, OnActivate, OnPaint. В обработчике события OnCreate можно сделать какие-либо инициализационные действия, однако, любые объекты созданные в OnCreate будут уничтожены в событии OnDestroy.
OnShow Это событие генерируется, когда форма станет видимой. OnShow вызывается сразу перед тем, как форма станет видимой. Это событие случается, если установить свойство формы Visible в True, либо при вызове методов Show или ShowModal.
OnActivate Это событие генерируется, когда форма становится активной, тоесть когда форма получает фокус ввода. Это событие можно использовать для того, чтобы сменить элемент формы который должен получить фокус.
OnPaint, OnResize Эти события вызываются каждый раз, когда форма изначально создаётся. При этом OnPaint вызывается каждый раз, когда какому-нибудь элементу формы необходимо перерисоваться (это событие можно использовать, если необходимо при этом рисовать на форме что-то особенное).
Жизнь формы в Delphi
Когда форма создана и все её элементы ждут своих событий, чтобы обрабатывать их, жизнь формы продолжается до тех пор, пока кто-нибудь не нажмёт крестик в верхнем правом углу формы!
Уничтожение формы в Delphi
При уничтожении формы, события генерируются в следующем порядке:
... OnCloseQuery -> OnClose -> OnDeactivate -> OnHide -> OnDestroy
OnCloseQuery Если мы попытаемся закрыть форму при помощи метода Close либо другим доступным способом (Alt+F4 либо через системное меню), то сгенерируется событие OnCloseQuery. Таким образом, это событие можно использовать, чтобы предотвратить закрытие формы. Обычно, событие OnCloseQuery используется для того, чтобы спросить пользователя - уверен ли он (возможно в приложении остались несохранённые данные).
procedure TForm1.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
begin
if MessageDlg(Really close this window?, mtConfirmation, [mbOk, mbCancel], 0) = mrCancel then
CanClose := False;
end;
Обработчик события OnCloseQuery содержит переменную CanClose, которая определяет, можно ли форме закрыться. Изначальное значение этой переменной True. Однако в обработчике OnCloseQuery можно установить возвращаемое значение CloseQuery в False, чтобы прервать выполнение метода Close.
OnClose Если OnCloseQuery вернул CanClose=True (что указывает на то, что форма должна быть закрыта), то будет будет сгенерировано событие OnClose. Событие OnClose даёт последний шанс, чтобы предотвратить закрытие формы. Обработчик OnClose имеет параметр Action со следующими четырьмя возможными значениями:
• caNone. Форме не разрешено закрыться. Всё равно, что мы установим CanClose в False в OnCloseQuery.
• caHide. Вместо закрытия, форма будет скрыта.
• caFree. Форма будет закрыта, и занятые ей ресурсы будут освобождены.
• caMinimize. Вместо закрытия, форма будет минимизирована. Это значение устанавливается поумолчанию у дочерних форм MDI.
Замечание: Когда пользователь выключает Windows, то будет вызвано OnCloseQuery, а не OnClose. Если Вы не хотите, чтобы Windows завершила свою работу, то поместите свой код вобработчик события OnCloseQuery, хотя CanClose=False не сделает, того, что сделано здесь.
OnDestroy После того, как метод OnClose будет обработан и форма будет закрыта, то будет вызвано событие OnDestroy. В OnCreate обычно делаются действия, противоположные тем, которые проделывались в OnCreate, то есть уничтожение созданных объектов и освобождение выделенной памяти.
Естественно, что когда главная форма проекта будет закрыта, то и приложение будет завершено.
Уничтожение формы (Release, Free или Destroy)
Уничтожение формы происходит с помощью методов Release, Free или Destroy, после чего работа с этой формой становится невозможна, и любая попытка обратиться к ней или ее компонентам вызовет исключение (ошибку). Необходимость уничтожения формы может возникнуть при оформлении заставок или при разработке больших приложений, требующих экономии оперативной памяти. Предпочтительным методом удаления формы считается метод Free, поскольку он предварительно проверяет возможность удаления. Например, в процедуре
Удаление формы методом Free
1. procedure TForm3.btnDestroyClick (Sender:TObject);
2. begin
3. Form3.Free;
4. end;
В приведенной процедуре кнопка btnDestroy уничтожает форму Form3. Для этой кнопки полезно задать соответствующий заголовок, например Удалить.

Cвойство FormStyle — стиль формы
Стиль формы определяется свойством FormStyle типа TFormstyle, принимающим следующие значения:
• fsNormal (стандартный стиль, используемый для большинства окон, в том числе и диалоговых);
• fsMDiChild (дочерняя форма в многодокументном приложении);
• fsMDiForm (родительская форма в многодокументном приложении);
• fsStayOnTop (форма, которая после запуска всегда отображается поверх других окон) — обычно используется при выводе системной информации или информационной панели программы.
Форма может изменять стиль динамически — в процессе выполнения программы, например, при выборе пункта меню. При изменении формой стиля возникает событие OnShow.
Пример динамического изменения стиля формы:
Динамическое изменение стиля формы
1. procedure TForm1.mnuTopClick(Sender:TObject);
2. begin
3. mnuTop.Checked := not mnuTop.Checked;
4. if mnuTop.Checked then Form1.FormStyle := fsStayOnTop else Form1.FormStyle :=fsNormal;
5. end;
При выборе пункта меню mnuTop форма переключает свой стиль между значениями fsNormal и fsStayOnTop. Смена стиля отображается графически галочкой в заголовке этого пункта меню.
Cвойство BorderStyle — свойства рамки формы

Каждая форма имеет ограничивающую рамку. Вид и поведение рамки определяет свойство BorderStyle типа TFormBorderstyle. Оно может принимать следующие значения:
• bsDialog (диалоговая форма);
• bsSingle (форма с неизменяемыми размерами);
• bsNone (форма не имеет видимой рамки и заголовка и не может изменять свои размеры) — часто используется для заставок;
• bsSizeable (обычная форма с изменяемыми размерами) — по умолчанию, имеет строку заголовка и может содержать любой набор кнопок;
• bsToolwindow (форма панели инструментов);
• bsSizeToolwin (форма панели инструментов с изменяемыми размерами).
Визуальное отличие между диалоговой и обычной формами заключается в том, что диалоговая форма может содержать в своем заголовке только кнопки закрытия и справки. Кроме того, пользователь не может изменять размеры диалоговой формы.
Невозможность изменения размеров форм некоторых стилей относится только к пользователю — нельзя с помощью мыши передвинуть границу формы в ту или иную сторону. Программно при выполнении приложения для формы любого стиля можно устанавливать любые допустимые размеры окна, а также изменять их.
Пример программного изменения размеров формы:
Программное изменение размеров формы
1. procedure TForm2.btnResizeFormClick(Sender:TObject);
2. begin
3. Form2.Width := Form2.Width + 100;
4. end;
При нажатии кнопки btnResizeForm ширина формы Form2 увеличивается на 100 пикселов, даже если ее свойство BorderStyle имеет значение, равное bsDialog, bsSingle или bsNone.
СОЗДАНИЕ ФОРМЫ
Система Delphi при добавлении новой формы в проект автоматически
создает один экземпляр класса (Form1, Form2 и т. д.), внося соответствующие изменения в файл проекта, например, добавляя строку кода:
Изменения в файле проекта Delphi при добавлении новой формы
1. Application.CreateForm(TForm1, Form1);
Управлять процессом автоматического создания форм можно, непосредственно редактируя файл проекта (не рекомендуется делать неопытным программистам) или выполняя настройки в окне параметров проекта (список Auto-create forms на странице Form). Если форма переведена из этого списка в список Available formsдоступных форм проекта, то инструкция ее создания исключается из файла проекта, и программист в ходе выполнения приложения должен динамически создать экземпляр этой формы.

На данном скринште мы видим, что Form1 будет создана при запуске программы, а Form2 необходимо будет создать динамически при выполнении программы.
Метод Сreate
Для создания экземпляров форм служит метод (конструктор) Сreate. Сам класс формы обычно предварительно описывается при конструировании приложения, и для формы уже существуют файлы формы (dfm) и программного модуля (pas).
Примерсозданияформы
1. procedure TForm1.Button1Click(Sender: TObject);
2. begin
3. // Форма создается, но не отображается на экране
4. Form2 := TForm2.Create(Application);
5. Form2.Caption := Новаяформа;
6. end;
В вышеуказанной процедуре создается форма Form2, принадлежащая объекту приложения и имеющая заголовок новая форма.

27. Построение пользовательского интерфейса. Компоненты для ввода и отображения информации на форме. Меню. Диалоги.
Перечень компонентов ввода и отображения текстовой информации:
Компонент Страница Описание
Label Standard Отображение текста, который не изменяется пользователем во время работы)
StaticText
(метка с бордюром) Additional В дополнение к Label обеспечивает возможность задания стиля бордюра.
Panel Standard Является контейнером для группирования элементов управления, но может
использоваться и для отображения текстовой информации.
Edit Standard Отображение, ввод и редактирование однострочных текстов
MaskEdit
(окно маскированного редактирования) Additional Используется для форматирования данных или для ввода символов в соответствии с шаблоном
Memo Standard Отображение ввод и редактирование многострочных текстов
RichEdit
(многострочное окно редактирования в формате rtf) Win32 Окно редактирования в обогащенном формате rtf, позволяющее производитьвыбор шрифтов, поиск текста и др.
ListBox
(окно списка) Standard Отображение стандартного окна списка Windows, позволяющее пользователю выбирать из него пункты (Items)
CheckListBox
(список с индикаторами) Additional Комбинация свойств списка ListBox и CheckBox
ComboBox
(редактируемый список) Standard Объединяет функции ListBox и Edit. Пользователь может либо ввести текст, либо выбрать его из списка (items)
StringGrid
(таблица) Additional Отображение текстовой информации в таблице из строк и столбцов с возможностью перемещаться по ячейкам и осуществлять выбор (Cells)

Компонент MainMenu является невизуальным, позволяет конструировать и создавать на форме полосу главного меню, а также сопутствующие выпадающие меню. Компонент MainMenu отображает на форме главное меню.
Основные свойства
Свойство Описание
• AutoHotKeys Определяет, могут ли горячие клавишиэлементов меню устанавливатьсяавтоматически
• AutoLine
• Redirection Указывает, проверяет ли Delphiпоявление в начале или конце подменюразделителей или двух разделителейподряд
• AutoMerge Определяет, объединяются ли главныеменю вспомогательных форм с главнымменю основной формы.
• Images Определяет список изображений, кото-рые могут отображаться в разделахменю слева от надписи.
• Items Список элементов меню типа TMenuEtem
Основные методы
Свойство Объявление / Описание
• Findltem type TFindltemKind = (fkCommand, fkHandle, fkShortCut); function FindItem(Value: Word; Kind: TFindltemKind):TMenuItem;Ищет и возвращает раздел меню, идентифицируемый значени¬ем Value, которое равно: при Kind = fkCommand — идентифи¬катору ID, используемому в сообщении Windows WM_COM-MAND; при Kind = fkHandle — дескриптору всплывающего меню; при Kind = fkShortCut — коду горячих клавиш.
• IsShortCut function IsShortCut(var Message:TWMKey): Boolean;Распознает горячие клавиши, связанные с разделом меню, и выполняет этот раздел меню.
• Merge procedure Merge(Menu:TMainMenu);Объединяет данное меню с указанным меню Menu вспомога¬тельной формы.
• Unmerge procedure Unmerge(Menu:TMainMenu);Уничтожает объединение указанного меню Menu вспомога¬тельной формы с данным меню.
Компоненты OpenDialog и SaveDialog в Delphi вызывают стандартные диалоги Windows открытия и сохранения файлов.
Открытие соответствующего диалога осуществляется методом Execute. Если в диалоге пользователь нажмет кнопку открыть (Сохранить), диалог закрывается, метод Execute возвращает true и выбранный файл отображается в свойстве компонента FileName. Если же пользователь отказался от диалога (нажал кнопку отмена или ESC), то метод Executeвозвращает false.
Значение свойства FileNamмоможно задать перед обращением к диалогу. Тогда оно появится в диалоге как значение по умолчанию в окне Имя файла. Таким образом, например, выполнение команды Сохранить как, по которой в файле с выбранным пользователем именем надо сохранить текст окна редактирования Memo1, может иметь вид:
SaveDialog1.FileName:=Fname;
if SaveDialog1.Execute
Then
Fname:=OpenDialog1.FileName;
Memo1.Lines.SaveToFile(FName);
End;
В этом коде предлагается, что имя файла хранится в строковой переменнойFName. Перед вызовом диалога это имя прередается в него как имя файла по умолчанию, а после выбора пользователем файла его выбор запоминается в той же переменной FName и тест сохраняется в этом файле методом SaveToFile.
Типы искомых файлов, появляющиеся в диалоге в выпадающем списке Тип файла задаются свойством Filter. В процессе проектирования это свойство вызывается нажатием кнопки с многоточием около имени этого свойства

в Инспекторе объектов. При этом открывается окно редактора:
В примере задан фильтр для документов Word с расширениями .doc и .rtf. После выхода из окна редактирования фильтров заданный вами шаблон появится в свойстве Filter в виде строки.
Свойство InitialDir определяет начальный каталог, который будет открыт в момент начала работы пользователя с диалогом. Свойство DefaultExtопределяет значение расширения файла по умолчанию. Если значение этого свойства не задано, пользователь должен указать в диалоге полное имя файла с расширением. Если же задать DefaultExt (например, «txt»), то пользователь может писать в диалоге имя без расширения. В этом случае будет принято заданное расширение.
Свойство Title позволяет вам задать заголовок диалогового окна.
28. Обработка исключительных ситуаций. Обработка исключительных ситуаций.

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

Вот как выглядит оператор контроля исключительных ситуаций:
try
основные операторы фрагмента;
except
альтернативный вариант фрагмента;
end;

Вначале производится попытка выполнить операторы секции try/except, содержащие основной вариант программы. При возникновении в каком-либо операторе этой секции исключительной ситуации остальные операторы секции пропускаются, и выполняется секция except/end. Если всё "проходит штатно", то секция except/end пропускается.

Ещё один вариант оператора контроля исключительных ситуаций применяется, когда необходимо, чтобы определённый фрагмент кода выполнился в любом случае, возникла исключительная ситуация или нет:
try
операторы
finally
заключительные действия
end;
Основные операторы, находящиеся в секции try, могут пройти штатно, или вызвать исключительную ситуацию. Операторы заключительных действий, находящиеся в секции finally, будут выполнены в любом случае.

Есть ещё один способ контроля исключительных ситуаций, касающийся ошибок операций ввода-вывода.
Перед участком программы, где возможны ошибки ввода-вывода (а это, по сути, все операторы ввода-вывода), ставится директива {$I-}, заставляющая компилятор не включать в код автоконтроль ошибок ввода-вывода. Таким образом, в случае ошибки ввода или вывода программа не прерывается. В конце участка с операторами ввода-вывода ставится директива, включающая автоконтроль: {$I+}. Затем анализируется результат вызова функции IOResult. Если функцияIOResult (вызывается без параметров) возвращает 0, значит ошибок ввода-вывода на данном участке не было.

Вот какой пример использования директив {$I} и функции IOResult содержит справка системы Delphi:
var
F: file of Byte;
begin
if OpenDialog1.Execute then
begin
AssignFile(F, OpenDialog1.FileName);
{$I-}
Reset(F);
{$I+}
if IOResult = 0 then
begin
MessageDlg(File size in bytes: + IntToStr(FileSize(F)), mtInformation, [mbOk], 0);
CloseFile(F);
end
else
MessageDlg(File access error, mtWarning, [mbOk], 0);
end;
end;

Delphi в наследство от Turbo Pascal. Тот же самый фрагмент можно составить и с использованием оператора try. На мой взгляд, это удобнее и проще.
При работе программы под управлением Delphi, система будет сама реагировать на исключительные ситуации, мешая работе операторов обработки исключений. Чтобы проверить их действие, можно запускать программу непосредственно, сворачивая Delphi и пользуясь ярлыком, установленном на Рабочем столе. Или можно отключить реакцию системы на исключительные ситуации, тем самым давая возможность отработать специально для этого написанным фрагментам программы - нашим операторам try/except/end. Для этого откроем пункт системного меню DelphiTools -> Debugger Options.... В появившемся окошке нужно снять галку в чекбоксе Stop on Delphi Exceptions, расположенном на вкладке Language Exceptions. Теперь система Delphi будет предоставлять вашей программе возможность самостоятельно обрабатывать исключительные ситуации, среди которых могут быть и ситуации, возникновение которых прописано специально как удобный инструмент достижения необходимых результатов.