Методические указания по выполнению практических работ по дисциплине Основы программирования

Ливенский филиал ПГУ

МЕТОДИЧЕСКИЕ РЕКОМЕНДАЦИИ

ДЛЯ СТУДЕНТОВ ПО ВЫПОЛНЕНИЮ

ПРАКТИЧЕСКИХ РАБОТ

для специальности 09.02.03 «Программирование в компьютерных системах»

"ОСНОВЫ ПРОГРАММИРОВАНИЯ"

2015

АННОТАЦИЯ

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

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

Составитель: ___________________ Е. Н. Шатохина, преподаватель кафедры естественнонаучных дисциплин

Ливенского филиала ПГУ

Рецензент: ____________________ Д. Н. Шолохов, преподаватель кафедры естественнонаучных дисциплин

Ливенского филиала ПГУ

Методические рекомендации рассмотрены и одобрены на заседании кафедры естественнонаучных дисциплин.

Протокол № ____ от «___»__________20__ г.

Зав. кафедрой канд.техн. наук, доцент _____________ В.И.Брусова

Методические рекомендации рассмотрены и одобрены на заседании научно-методического совета

Протокол № ____ от «___»__________ 20__ г.

Председатель НМС канд. соц. наук _____________ Е.А. Колякина

СОДЕРЖАНИЕ

Практическая работа №11. 49

Практическая работа № 1

Модули

Цель работы: закрепить знания о модулях; разработка модуля и программы с его использованием.

1 ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ

В стандартном языке Паскаль модули отсутствуют. Этот недостаток долгое время служил препятствием для применения Паскаля в качестве языка профессионального программирования. Модули появились в Турбо Паскале начиная с версии 4.0. Это сразу же вывело Турбо Паскаль на передовые позиции профессионального программирования.

Модуль не представляет собой исполняемой программы, а только содержит набор средств для использования в исполняемой программе: типы данных, переменные, процедуры и функции. Исходный текст модуля имеет расширение .pas. Модуль компилируется отдельно от основной программы, откомпилированный модуль имеет расширение .tpu (Turbo Pascal Unit). Готовый откомпилированный модуль может быть использован в основной программе с помощью предложения uses, которое записывается сразу же после имени программы.

В Турбо Паскале имеются стандартные модули: DOS, CRT (Cathode Ray Tube, электронно-лучевая трубка), Printer, Graph, System и другие. Их не надо описывать, а можно сразу включать в программу предложением uses. Модуль System используется во всех программах, поэтому для него сделано исключение, его можно не включать в предложение uses, он будет подключен автоматически. Остальные модули требуют включения в предложение uses, если в программе используются ресурсы модуля, например, процедуры и функции.

Назначение стандартных модулей следующее. Модуль DOS использует системные ресурсы операционной системы MS-DOS . Возможно использование регистров, обслуживание прерываний, вызов других программ из программы на Паскале. Модуль CRT используется для обслуживания видеомонитора, клавиатуры, встроенного динамика. Процедуры очистки экрана clrscr и ожидание нажатия клавиши readkey содержатся именно в модуле CRT.

Модуль Graph содержит богатейший набор графических процедур и функций: проведение линий, работа с цветом, вызов графических примитивов, работа с текстом в графическом режиме, закраска замкнутых областей и т.п. Экран в графическом режиме рассматривается как набор пикселей. Модуль Printer служит для вывода информации на принтер.

Кроме стандартных модулей, в Турбо Паскале возможны модули пользователя, Они требуют описания, которое начинается ключевым словом языка unit и содержат 3 раздела: раздел интерфейса (interface), раздел реализации (implementation), раздел инициализации (необязательный).

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

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

Рассмотрим пример модуля для работы с комплексными числами. Комплексное число состоит из двух вещественных чисел, действительной и мнимой частей соответственно. Пусть имеются два комплексных числа x и y: x=a+bi; y=c+di. Здесь i квадратный корень из минус единицы (мнимая единица), причем i²= - 1. Если комплексное число z=e+fi, и z есть результат операции над x и y, то

z=x+y; e=a+c: f=b+d; (сложение)

z=x-y; e=a-c: f=b-d; (вычитание)

z=x*y; e=a*c-b*d: f=a*d+b*c; (умножение)

z=x/y; e=(a*c+b*d)/(c2+d2): f=(c*b-a*d)/(c2+d2): (деление)

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

Для организации операций над комплексными числами представим каждое комплексное число в виде записи из двух полей вещественного типа: Re -действительная часть, Im - мнимая часть. Создадим модуль complex, в котором опишем комплексный тип com с двумя полями. В этом же модуле в разделе интерфейса опишем процедуры ad (сложение), su (вычитание), mu (умножение), di (деление) комплексных чисел (только заголовки). Тела процедур поместим в раздел реализации модуля. Раздел инициализации имеет вид:

begin

операторы

end.

Если раздел инициализации не содержит операторов, как в нашем примере, достаточно написать только end. Пример модуля complex.pas.

unit complex;{модуль арифметики комплексных чисел}

{$N+}

interface

uses dos,crt;

type com=record

re,im:real;

end;

var a,b,c:com;

procedure ad(var a,b,c:com);{сложение, c=a+b}

procedure su(var a,b,c:com);{вычитание, c=a-b}

procedure mu(var a,b,c:com);{умножение, c=a*b}

procedure di(var a,b,c:com);{деление, c=a/b, случай b =0 не предусмотрен }

procedure wr_com(var p:com); {печать комплексного числа}

implementation

procedure ad(var a,b,c:com);

begin c.re:=a.re+b.re;

c.im:=a.im+b.im;

end;{ad}

procedure su(var a,b,c:com);

begin c.re:=a.re-b.re;

c.im:=a.im-b.im;

end;{su}

procedure mu(var a,b,c:com);

begin c.re:=a.re*b.re-a.im*b.im;

c.im:=a.re*b.im+a.im*b.re;

end;{mu}

procedure di(var a,b,c:com);

var d:real;

begin d:=b.re*b.re+b.im*b.im;

c.re:=(a.re*b.re+a.im*b.im)/d;

c.im:=(b.re*a.im-a.re*b.im)/d;

end;{di}

procedure wr_com(var p:com);

begin

if p.im<0 then writeln(p.re:9:5,'-',-p.im:9:5,'i') else

writeln(p.re:9:5,'+',p.im:9:5,'i');

end;{wr_com}

begin

end.{unit}

Как уже было указано, модуль не может непосредственно выполняться. Нужно разработать основную программу, которая использует ресурсы модуля. В данном случае это программа com_arif.pas (комплексная арифметика). В программе вводятся 2 комплексных числа, затем с ними выполняются действия сложения, вычитания, умножения и деления, результаты выводятся на экран.

program com_arif;

uses complex;

var x,y,z:com; {тип com определен в модуле complex}

begin

writeln('Введите дейст. и мн. части первого числа');

read(x.re,x.im);

writeln('Введите дейст. и мн. части второго числа');

read(y.re,y.im);

write('x='); wr_com(x);

write('y='); wr_com(y);

ad(x,y,z); {z=x+y}

write('x+y=');wr_com(z);

su(x,y,z); {z=x-y}

write('x-y=');wr_com(z);

mu(x,y,z); {z=x*y}

write('x*y=');wr_com(z);

di(x,y,z); {z=x/y}

write('x/y=');wr_com(z);

end.

2 ВЫПОЛНЕНИЕ РАБОТЫ

В работе требуется внимательно рассмотреть и разобрать построчно, приведенные примеры.

3 ФОРМА ОТЧЕТА

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

4 КОНТРОЛЬНЫЕ ВОПРОСЫ

1. Какое расширение имеет исходный файл модуля? Откомпилированный файл?

2. Какие разделы имеются в модуле? Какой раздел модуля доступен для программ и других модулей? Какой недоступен?

3. Какие ресурсы модуля могут использоваться в программах?

4. Каковы преимущества использования модулей?

5. Имеется ли в разработанном вами модуле раздел инициализации?

6. Назначение раздела инициализации модуля.

7. В каком разделе модуля помещаются тела процедур и функций?

Практическая работа № 2

Создание библиотек подпрограмм в Turbo Pascal. Связь модулей друг с другом

Цель работы: ознакомиться с созданием библиотек подпрограмм, получить начальные сведения о связи модулей в Turbo Pascal.

1 ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ

Стандартный язык Pascal не располагает средствами разработки и поддержки библиотек программиста (в отличие, скажем, от языка Fortran и других языков программирования высокого уровня), которые компилируются отдельно и в дальнейшем могут быть использованы как самим разработчиком, так и другими. Если программист имеет достаточно большие наработки, и те или иные подпрограммы могут быть использованы при написании новых приложений, то приходится эти подпрограммы целиком включать в новый текст.

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

Начнем с внешних подпрограмм.

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

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

1. Дано натуральное число n. Найти сумму первой и последней цифры этого числа.

2. Дано натуральное число n. Переставить местами первую и последнюю цифры этого числа.

3. Дано натуральное число n. Дописать к нему цифру kв конец и в начало (если это возможно, т.е. результат не выйдет за диапазон допустимых значений), или сообщить о невозможности выполнения операции.

4. Найти наибольшую цифру в записи данного натурального числа.

5. Дано натуральное число n. Переставить его цифры так, чтобы образовалось максимальное число, записанное теми же цифрами.

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

Вот возможный вариант такой функции:

Function Digits(N: LongInt): Byte;

Var Kol: Byte;

Begin

Kol := 0;

While N <> 0 Do Begin Kol := Kol + 1; N := N Div 10 End;

Digits := Kol

End;

Сохраним этот текст в файле с расширением .inc (это расширение внешних подпрограмм в Turbo Pascal), например, digits.inc.

Еще необходима функция возведения натурального числа в натуральную степень.

Function Power(A, N: LongInt): LongInt; {файл power.inc}

Var I, St: LongInt;

Begin

St := 1;

For I := 1 To N Do St := St * A;

Power := St

End;

Попробуем использовать функции при решении задачи номер один.

Program Example1;

Var N, S: LongInt;

{$I digits.inc} {подключаем внешнюю функцию digits.inc, возвращающую количество цифр в записи числа}

{$I power.inc} {внешняя функция, выполняющая возведение числа A в степень N}

Begin

Write('Введите натуральное число: ');

ReadLn(N);

{для определения последней цифры числа N берем остаток от деления этого числа на 10, а для определения первой делим N на 10 в степени на единицу меньшую, чем количество цифр в записи числа (нумерация разрядов начинается с 0)}

S := N Mod 10 + N Div Power(10, Digits(N) - 1);

WriteLn('Искомая сумма: ', S)

End.

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

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

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

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

Модуль имеет следующую структуру:

Unit <имя модуля>; {заголовок модуля}

Interface

{интерфейсная часть}

Implementation

{разделреализации}

Begin

{раздел инициализации модуля}

End.

После служебного слова Unit записывается имя модуля, которое (для удобства дальнейших действий) должно совпадать с именем файла, содержащего данный модуль. Поэтому (как принято в MS DOS) имя не должно содержать более 8 символов.

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

В разделе Implementation реализуются все подпрограммы, которые были ранее объявлены. Кроме того, здесь могут содержаться свои константы, переменные, типы, подпрограммы и т.д., которые носят вспомогательный характер и используются для написания основных подпрограмм. В отличие от ресурсов, объявленных в разделе Interface, все, что дополнительно объявляется в Implementation, уже не будет доступно при подключении модуля. При написании основных подпрограмм достаточно указать их имя (т.е. не нужно полностью переписывать весь заголовок), а затем записать тело подпрограммы.

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

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

Задача. Реализовать в виде модуля набор подпрограмм для выполнения следующих операций над обыкновенными дробями вида P/Q (P- целое, Q- натуральное):

1) сложение; 2) вычитание; 3) умножение; 4) деление; 5) сокращение дроби; 6) возведение дроби в степень N (N- натуральное); 7) функции, реализующие операции отношения (равно, не равно, больше или равно, меньше или равно, больше, меньше).

Дробь представить следующим типом:

Type Frac = Record

P: Integer;

Q: 1… High(LongInt)

End;

Unit Droby;

Interface

Type

Natur = 1..High(LongInt);

Frac = Record

P: LongInt; {Числитель дроби}

Q: Natur {Знаменатель дроби}

End;

Procedure Sokr(Var A: Frac);

Procedure Summa(A, B: Frac; Var C: Frac);

Procedure Raznost(A, B: Frac; Var C: Frac);

Procedure Proizvedenie(A, B: Frac; Var C: Frac);

Procedure Chastnoe(A, B: Frac; Var C: Frac);

Procedure Stepen(A: Frac; N: Natur; Var C: Frac);

Function Menshe(A, B: Frac): Boolean;

Function Bolshe(A, B: Frac): Boolean;

Function Ravno(A, B: Frac): Boolean;

Function MensheRavno(A, B: Frac): Boolean;

Function BolsheRavno(A, B: Frac): Boolean;

Function NeRavno(A, B: Frac): Boolean;

{Раздел реализации модуля}

Implementation

{Наибольший общий делитель двух чисел - вспомогательная функция, ранее не объявленная}

Function NodEvklid(A, B: Natur): Natur;

Begin

While A <> B Do

If A > B Then

If A Mod B <> 0 Then A := A Mod B Else A := B

Else

If B Mod A <> 0 Then B := B Mod A Else B := A;

NodEvklid := A

End;

Procedure Sokr; {Сокращение дроби}

Var M, N: Natur;

Begin

If A.P <> 0 Then

Begin

If A.P < 0 Then M := Abs(A.P)

Else M := A.P; {Совмещение типов, т.к. A.P - LongInt}

N := NodEvklid(M, A.Q); A.P := A.P Div N; A.Q := A.Q Div N

End

End;

Procedure Summa; {Сумма дробей}

Begin

{Знаменатель дроби} C.Q := (A.Q * B.Q) Div NodEvklid(A.Q, B.Q);

{Числитель дроби} C.P := A.P * C.Q Div A.Q + B.P * C.Q Div B.Q;

Sokr(C)

End;

Procedure Raznost; {Разность дробей}

Begin

{Знаменатель дроби} C.Q := (A.Q * B.Q) Div NodEvklid(A.Q, B.Q);

{Числитель дроби} C.P := A.P * C.Q Div A.Q - B.P * C.Q Div B.Q;

Sokr(C)

End;

Procedure Proizvedenie;

Begin

{Знаменатель дроби} C.Q := A.Q * B.Q;

{Числитель дроби} C.P := A.P * B.P;

Sokr(C)

End;

Procedure Chastnoe;

Begin

{Знаменатель дроби} C.Q := A.Q * B.P;

{Числитель дроби} C.P := A.P * B.Q;

Sokr(C)

End;

Procedure Stepen; {Степень}

Var I: Natur;

Begin

C.Q := 1; C.P := 1; Sokr(A);

For I := 1 To N Do Proizvedenie(A, C, C)

End;

Function Menshe;

Begin Menshe := A.P * B.Q < A.Q * B.P End;

Function Bolshe;

Begin Bolshe := A.P * B.Q > A.Q * B.P End;

Function Ravno;

Begin Ravno := A.P * B.Q = A.Q * B.P End;

Function BolsheRavno;

Begin BolsheRavno := Bolshe(A, B) Or Ravno(A, B) End;

Function MensheRavno;

Begin MensheRavno := Menshe(A, B) Or Ravno(A, B) End;

Function NeRavno;

Begin NeRavno := Not Ravno(A, B) End;

{Раздел инициализации модуля}

Begin

End.

Дадим некоторые рекомендации по разработке модулей:

1) спроектировать модуль, т.е. выделить основные и вспомогательные подпрограммы, другие ресурсы;

2) каждую подпрограмму целесообразно отладить отдельно, после чего «вклеить» в текст модуля.

Сохраним текст разработанной программы в файле DROBY.PAS и откомпилируем наш модуль. Для этого можно воспользоваться внешним компилятором, поставляемым вместе с Turbo Pascal. Команда будет выглядеть так: TPC DROBY.PAS. Если в тексте нет синтаксических ошибок, получим файл DROBY.TPU, иначе будет соответствующее сообщение с указанием строки, содержащей ошибку. Другой способ компиляции модуля - в среде программирования Turbo Pascal выбрать в пункте меню Run подпункты Make или Build (при этом должна быть включена компиляция на диск).

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

Для примера решим задачу суммирования массива дробей.

Program Sum;

Uses Droby;

Var A: Array[1..100] Of Frac;

I, N: Integer;

S: Frac;

Begin

Write('Введите количество элементов массива: ');

ReadLn(N);

S.P := 0; S.Q := 1; {Первоначально сумма равна нулю}

For I := 1 To N Do {Вводим и суммируем дроби}

Begin

Write('Введите числитель', I, '-йдроби: '); ReadLn(A[I].P);

Write('Введите знаменатель', I, '-йдроби: '); ReadLn(A[I].Q);

Summa(A[I], S, S);

End;

WriteLn('Ответ: ', S.P, '/', S.Q)

End.

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

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

Ещё несколько слов о видимости объектов модуля. Если в программе, использующей модуль, имеются идентификаторы, совпадающие с точностью до символа с идентификаторами модуля, то они «перекрывают» соответствующие ресурсы модуля. Тем не менее, даже в такой ситуации доступ к этим ресурсам модуля может быть получен таким образом: <имя модуля>.<имя ресурса>.

2 ВЫПОЛНЕНИЕ РАБОТЫ

В работе требуется внимательно рассмотреть и разобрать построчно приведенные примеры.

3 ФОРМА ОТЧЕТА

В работе отчет должен содержать краткое изложение теории, ответы на вопросы.

4 КОНТРОЛЬНЫЕ ВОПРОСЫ

1. Какой механизм работы предусмотрен для внешних подпрограмм (приведите примеры)

2. Какая директива подключает внешние функции и процедуры?

3. Кратко опишите конструкцию модуля и дайте характеристику каждому разделу.

4. Составьте алгоритм действий по созданию модулей.

5. Создайте полную программу для нахождения суммы дробей (дана в теоретической части)

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

Практическая работа № 3

Файловый тип

Цель работы: ознакомиться с файловым типом языка. Рассмотреть принципы работы с файлами.

1 ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ

Работа с файлами

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

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

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

Типизированный файл в Паскале интерпретируется как последовательность (список) значений определенного (одного и того же) базового типа. Например, если в файле на диске хранится список вещественных чисел, то переменная в языке Pascal, через которую можно получить к ним доступ, может быть описана так:

f: file of real;

Файловый тип определяется служебными словами file of, далее идет указание базового типа, который может быть любым, кроме файлового.

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

При определении переменной файлового типа также в программе появляется скрытый (неявный) текущий указатель файла. Его назначение - указывать на конкретный элемент файла (обеспечивать доступ к нему).

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

Операции с файловыми переменными включают:

• установочные и завершающие операции;

• ввод и вывод;

• перемещение по файлу;

• специальные операции.

Создание файла и запись данных в него

var

f: file of char;

c: char;

i, n: byte;

begin

assign (f, 'c:\file.txt');

rewrite (f);

write ('Количество символов: ');

readln (n);

for i:=1 to n do begin

write ('Введите символ: ');

readln (c);

write (f, c);

end;

close (f);

end.

Процедура assign обеспечивает связь файловой переменной программы с реальным файлом на диске. Первым аргументом указывается переменная, вторым - адресное имя файла.

Процедура rewrite открывает файл в режиме записи, т.е. мы можем вводить данные в файл с помощью процедуры вывода из программы write. Если указанный файл отсутствует на диске, то он будет создан. Если файл существует и содержит данные, то все они будут удалены и заменены в дальнейшем новыми (перезаписаны).

Запись данных в файл - результат выполнения процедуры write (f, c), где f - файловая переменная, а с - выводимый из программы, но вводимый в файл символ.

В конце требуется закрыть файл и «освободить» переменную f. Это делается с помощью процедуры close.

Чтение данных из файла

var

f: file of char;

c: char;

begin

assign (f, 'c:\file.txt');

reset (f);

while not eof (f) do begin

read (f, c);

writeln (c);

end;

close (f);

readln

end.

Процедура reset открывает файл для чтения. Т.е. мы можем в дальнейшем в программе извлекать данные из файла с помощью процедуры read.

Данные извлекаются «порциями» базового типа. В данном примере - это char (символы).

Чтение данных из файла продолжается до тех пор, пока не будет достигнут конец файла. Функция eof проверяет достигнут ли конец файла, переданного ей в качестве аргумента и, если достигнут, возвращает true. Выражение not eof (f) проверяет обратное - то, что конец файла еще не достигнут.

Функция IOResult

var

f: file of char;

c: char;

r: integer;

begin

assign (f, 'c:\file1.txt');

{$I-}

reset (f);

{$I+}

r := ioresult;

if r <> 0 then

writeln ('Такого файла нет')

else

while not eof (f) do begin

read (f, c);

writeln (c);

end;

close (f);

readln

end.

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

Чтобы избежать преждевременного выхода из программы, можно отключить автоматический контроль ошибок ({$I-}) и воспользоваться функцией IOResult.

Функция IOResult возвращает ноль лишь в том случае, если файл существует.

Редактирование файла

var

f: file of char;

c: char;

n: integer;

begin

assign (f, 'c:\file.txt');

reset (f);

write ('Номер элемента: ');

readln (n);

seek (f, n);

write ('Новый символ: ');

readln (c);

write (f, c);

close (f);

readln

end.

В языке программирования Pascal для редактирования файлов предназначена процедура seek. В качестве аргументов она принимает файловую переменную и номер заменяемого элемента. В это место помещается текущий указатель файла. Далее с помощью write производится запись в файл.

Предварительно файл необходимо открыть для чтения (reset).

Текстовые файлы

Текстовые файлы состоят из символьных строк переменной длины. Каждая строка завершается специальной комбинацией, называемой «конец строки». Комбинация «конец строки» состоит из двух символов: «перевод каретки» (ASCII-код #13) и «перевод строки» (#10). Завершается текстовый файл символом «конец файла» (#26).

Описание текстового файла осуществляется объявлением переменной типа Text:

var файловая_переменная: Text;

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

Отличие операторов Read и ReadLn при чтении из текстовых файлов состоит в том, что оператор ReadLn, поместив значение в последнюю переменную списка ввода, переходит на начало следующей строки, не считывая оставшиеся в строке данные. С другой стоны, оператор Read остается готовым считывать данные со следующей позиции текущей строки. Так, предположим, что в текстовом файле f имеются две строки:

В этом случае два оператора Read(f,m); Read(f,n); поместят в целочисленные переменные m и n соответственно значений 1 и -2, а два оператора ReadLn(f,m); ReadLn(f,n); считают значения 1 и 4.

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

Типизированные файлы

Более характерным для Pascal являются типизированные файлы, или файлы произвольного доступа. Основным свойством этих файлов является то, что их структура данных представляет собой последовательность компонентов одного типа. Описывают подобный файл словосочетанием file of с последующим указанием типа компонентов файла, число которых (длина файла) не фиксируется:

var имя_файла: file of тип_компонентов

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

var

FileInt: file of Integer

В этом описании указано, что элементами файла являются данные типа Integer, занимающие 2 байта (или 4?). При этом отпадает необходимость в специальном разделении элементов файла, как это делалось в текстовых файлах. Также возможен произвольный доступ к элементам данных (этим типизированный файл несколько напоминает одномерный массив).

Чтобы можно было работать с типизированным файлом, необходимо, как и для текстовых файлов, сначала связать имя файловой переменной с внешним именем файла (оператор Assign). Затем нужно открыть его (используются операторы Reset и Rewrite, но не Append). Операторы Reset и Rewrite открывают файл и для чтения, и для записи (а не только для чтения или только для записи, как при использовании текстовых файлов). Отличие их в том, что оператор Reset открывает только существующий файл (если такого файла нет, будет сгенерирована ошибка времени выполнения). С другой стороны, оператор Rewrite создает новый файл (если файл с таким именем уже имеется, то он будет уничтожен и создан заново). При открытии файла с ним связывается текущий указатель файла, который позиционируется на его первый элемент. Оперировать можно только тем элементом файла, на который ссылается указатель файла. При чтении или записи элемента файла происходит автоматическое перемещение указателя на следующий элемент. Чтение из типизированного файла производится оператором Read (но не ReadLn), а запись в него - оператором Write (но не WriteLn). Однако следует помнить, что в списке вывода оператора Write могут быть только переменные. Типы элементов файла и типы переменных в списках ввода-вывода должны быть согласуемы по присваиванию. Элементами типизированных файлов могут быть числовые, символьные, булевы, строковые значения, массивы, записи, но не файлы или структуры с файловыми элементами.

Узнать количество элементов типизированного файла (размер файла) можно с помощью функции FileSize, для которой используется следующий синтаксис:

FileSize(имя_файла)

Например, если переменная k имеет тип LongInt, а f - файловая переменная типизированного файла, то оператор k := FileSize(f), записывает в переменную k размер файла f.

Элементы типизированного файла нумеруются с нуля (порядковый номер последнего элемента файла на единицу меньше размера файла). Чтобы узнать, на каком элементе располагается указатель файла, используют функцию FilePos:

FilePos(имя_файла)

Текущим положением указателя можно управлять, для чего служит процедура Seek, которая использует следующий синтаксис:

Seek(имя_файла, номер_элемента)

Второй параметр (тип LongInt) задает номер элемента (отсчет от 0), на который должен переместиться указатель файла. Рассмотрим несколько примеров.

Перейти к пятому (фактически шестому) элементу файла f:

Seek(f, 5);

Перейти к предыдущему элементу:

Seek(f, FilePos(f)-1);

Перейти в конец файла:

Seek(f, FilePos(f)-1);

Как и для текстовых файлов, можно использовать функцию Eof(имя_файла), которая возвращает значение True, если текущий указатель расположен на признаке конца файла (т. е. при выполнении равенства FilePos(имя_файла) = FileSize(имя_файла)).

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

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

Нетипизированные файлы

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

var имя_файла: file;

Например, возможно такое описание:

var FileOneType: file;

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

Открываются файлы без типа теми же операторами Reset и Rewrite, но в этом случае имеется второй параметр - размер записи (элемента файла), заданный в байтах. Предварительно нужно с помощью оператора Assign связать внутреннее имя файла с внешним:

Assign(FileOneType, 'f.dat'); Reset(fileOneType, 1);

Второй параметр операторов Reset и Rewrite может быть опущен, что означает задание размера записи в 128 байт. Наибольшая скорость обмена данными обеспечивается при длине записи, кратной 512 байт (размеру сектора на диске).

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

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

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

BlockRead(имя_файла, переменная_буфер, количество_записей)

Третий параметр - это количество записей, читаемых за один раз (тип Word).

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

Запись данных в нетипизированный файл производится только после его открытия с помощью процедуры Rewrite. Для записи данных используется процедура BlockWrite, которая имеет те же три (или четыре) параметра, что и BlockRead. При этом в переменную_буфер нужно предварительно поместить записи. Количество этих записей должно совпадать со значением третьего параметра процедуры BlockWrite, а размер - со вторым параметром процедуры Rewrite. В четвертом параметре процедуры BlockWrite (если он имеется) возвращается количество фактически помещенных в фал записей. Если на диске нет свободного места, то после выполнения процедуры BlockWrite значения третьего и четвертого параметров будут отличаться.

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

2 ВЫПОЛНЕНИЕ РАБОТЫ

В работе требуется внимательно рассмотреть и разобрать построчно приведенные примеры. Оформить отчет.

3 ФОРМА ОТЧЕТА

Отчет должен содержать ответы на вопросы.

4 КОНТРОЛЬНЫЕ ВОПРОСЫ

1. Дайте определение файловому типу.

2. Что включают операции с файловыми переменными.

3. Опишите процедуры и функции, предназначенные для работы с файлами.

4. Дать определение текстовому файлу.

5. Опишите работу типизированных файлов.

6. Опишите работу нетипизированных файлов.

Практическая работа № 4

Операции для работы с файловой системой

Цель работы: ознакомиться с операциями, предназначенными для работы с файловой системой.

1 ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ

В Pascal существует несколько процедур для работы с файловой структурой.

Процедура Rename служит для переименования файла или каталога. Синтаксис процедуры следующий:

Rename(файловая_переменная, новое_имя)

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

Для уничтожения файла в Pascal используется процедура Erase, единственным параметром которой является внутреннее имя файла.

Erase(файловая_переменная)

Эти две процедуры работают только с закрытым файла, но предварительно с помощью оператора Assign файловая переменная (тип которой неважен) должна быть связана с внешним именем файла (или каталога, если переименовывается каталог).

Четыре процедуры (ChDir, MkDir, RmDir и GetDir) в Pascal обеспечивают работу с каталогами.

Первые три процедуры используют один и тот же синтаксис:

ChDir(каталог)

MkDir(каталог)

RmDir(каталог)

Во всех трех случаях параметр задается строковым выражением и указывает имя каталога в интерпретации MS DOS.

Процедура ChDir изменяет текущий каталог на указанный, процедура MkDir создает новый каталог с указанным именем, а процедура RmDir уничтожает каталог при условии, что он пустой.

Процедура GetDir позволяет определить имя текущего каталога на указанном диске. Синтаксис процедуры таков:

GetDir(диск, каталог)

Здесь параметр диск представляет собой выражение типа Word, задающее номер диска (0 - активный диск, 1 - диск A, 2 - диск B и т. д.). Параметр каталог - это переменная типа string, которая служит для возврата пути к текущему каталогу на диске, номер которого указан в качестве первого параметра процедуры. Пример использования описанных выше процедур представлен в программе ниже.

var

f: text;

s: string;

begin

Assign(f,'a.txt'); // связываемся с файлом

Rename(f,'b.txt'); // переименовываем его

MkDir('foto'); // создаем каталог

ChDir('foto'); // переходим в него

GetDir(0,s); // полное имя текущего каталога записываем в s

writeln(s);

ChDir('..'); // поднимаемся на уровень вверх

rewrite(f); // открываем файл на запись

write(f,s); // записываем туда строку

close(f);

readln; // пока не нажата клавиша, вы можете видеть каталог

RmDir('foto'); // удаляем каталог

end.

2 ВЫПОЛНЕНИЕ РАБОТЫ

В работе требуется внимательно рассмотреть и разобрать построчно приведенные примеры. Оформить отчет.

3 ФОРМА ОТЧЕТА

Отчет должен содержать ответы на вопросы.

4 КОНТРОЛЬНЫЕ ВОПРОСЫ

1. Дать определение файловой структуре.

2. Опишите работу процедур, предназначенных для работы с файловой структурой.

3. Предложите свой пример использования описанных процедур.

Практическая работа № 5

Объектно-ориентированная модель программирования. Объекты.

Цель работы: получить теоретические сведения об объектах ООП.

1 ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ

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

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

Объектная декомпозиция

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

Элементы системы, параметры и поведение которой определяются условием задачи, обладающие самостоятельным поведением (т. е. «умеющие» выполнять некоторые действия, зависящие от полученных сообщений и состояния элемента), получили название объектов.

Процесс представления предметной области в виде совокупности объектов, обменивающихся сообщениями, называется объектной декомпозицией.

Упражнение 1. Выполните объектную декомпозицию программы, которая по запросу пользователя рисует точку, окружность или квадрат.

Решение

По правилам объектной декомпозиции разрабатывается имитационная модель программы. Для этого необходимо проанализировать все происходящие в системе процессы и выделить элементы, обладающие собственным поведением, воздействующие на другие элементы и/или являющиеся объектами такого воздействия.

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

Фигуры получают следующие сообщения: нарисовать, изменить цвет контура, изменить размер, изменить координаты. Все эти сообщения инициируются Менеджером в соответствии с командой пользователя. Получив от пользователя команду Завершить, Менеджер прекращает выполнение программы.

Упражнение 2. Выполните объектную декомпозицию системы «Телефонный справочник».

Решение

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

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

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

Каждый объект, получив сообщение, должен определенным образом реагировать на них, выполняя заранее определенные для каждого типа сообщения действия. Например, если объект ОбработатьЗапись будет активизирован, то он должен будет проанализировать, какое именно действие нужно выполнить. Если принято сообщение Редактировать, то объект должен сохранить запись в файл, на место, указанное курсором.

Состояние объекта характеризуется набором конкретных значений некоторого перечня всех возможных свойств данного объекта; например, состояние объекта Файл характеризуется значениями «активизирован» - «не активизирован». Это состояние объекта необходимо для выполнения всех действий над записной книжкой: если Файл находится в состоянии «не активизирован», то ни одно сообщение не сможет быть обработано.

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

Поведение объектов характеризуется определенным набором реакций на получаемые сообщения и зависит от состояния объекта.

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

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

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

2 ВЫПОЛНЕНИЕ РАБОТЫ

В работе требуется внимательно рассмотреть и разобрать приведенные примеры.

3 ФОРМА ОТЧЕТА

Отчет должен содержать разобранные примеры, ответы на вопросы.

4 КОНТРОЛЬНЫЕ ВОПРОСЫ

1. Понятие ООП.

2. В чем состоит концептуальное отличие структурного программиро­вания от объектно-ориентированного программирования?

3. Что называется объектом?

4. Дать определение объектной декомпозиции.

5. Правила разработки имитации модели программы.

6. Дайте характеристику состоянию объекта.

7. Перечислите этапы операции селекции.

8. Перечислите этапы операции модификации.

Практическая работа № 6

Объектно-ориентированная модель программирования. Классы и методы.

Цель работы: получить теоретические сведения о классах и методах ООП.

1 ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ

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

Абстрагирование - это один из главных способов решения сложных задач.

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

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

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

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

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

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

Для корректной работы абстракции доступ к ее внутренней структуре должен быть ограничен. Для этого вводятся две части в описании абстракции.

Интерфейс - это совокупность доступных извне элементов реализации абстракции, т. е. основные характеристики состоя­ния и поведения.

Реализация - это совокупность недоступных извне элемен­тов реализации абстракции, т. е. внутренняя организация абст­ракции и механизмы реализации ее поведения.

Наличие интерфейса обеспечивает уменьшение возможности «разрушения» (несанкционированного изменения значений полей) объекта извне. При этом сокрытие особенностей реализации упрощает внесение изменений в реализацию класса как в процессе отладки, так и при модификации программы. Таким образом, класс определяет существование глобальной области данных внутри объекта, доступной методам объекта. С другой стороны, доступ к объекту регламентируется и должен выполняться через специальный интерфейс.

Для описания нового класса в языке Object Pascal определен следующий синтаксис:

Туре <имя_объявляемого_класса>=с1аss(<имя_класса_родителя>) Private

<скрытые_элементы_класса> Protected

<защищенные_элементы_класса> Public

<общедоступные_элементы_класса> Published

<опубликованные_элементы_класса> end;

Директивы private, protected, public, published предназначены для ограничения доступа к элементам класса.

Секция private содержит внутренние элементы, обращение к которым возможно только в пределах модуля, содержащего объявление класса.

Секция protected содержит защищенные элементы, которые доступны в пределах модуля, содержащего определение класса, и внутри классов-потомков.

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

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

Потомки класса могут менять область доступности всех эле­ментов родительского класса, кроме элементов, объявленных в секции private, так как последние им недоступны.

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

Упражнение 1 Разработать класс, переменные которого используются для описания положения геометрической фигуры на экране.

Решение

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

Определим класс ";background: #ffffff; widows: 0; orphans: 0">

Для хранения значений координат введем два поля Fx и Fy (в языке Object Pascal принято соглашение названия полей на­чинать с символа F (от слова Field - поле)). Это внутренние данные класса, чтобы обеспечить их целостность, опишем их в разделе private.

Constructor Create предназначен для создания экземпляра класса (объекта), а также для определения начальных значений его полей.

Destructor Destroy предназначен для удаления объекта из динамической памяти.

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

Итак, объединение данных с действиями над этими данными порождает новый тип, а процесс называется инкапсуляцией.

Создавая объекты типа TPosition, инициализируя их в соответствии с условием, получим разные положения на экране, причем параметры будут храниться внутри объектов.

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

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

<имя_объекта>.<имя_поля>; ИЛИ

<имя_объекта>.<имя_метода>;

Все методы объекта обязательно имеют доступ ко всем полям своего объекта. В языке Object Pascal это достигается через неявную передачу в метод специального параметра Self - адреса области данных конкретного объекта. Таким образом, уменьшается количество параметров, явно передаваемых в метод.

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

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

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

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

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

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

Правила разделения системы на модули.

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

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

Иерархия. Значительное упрощение в понимании сложных задач достигается за счет образования из абстракций иерархической структуры.

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

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

В ООП используют два вида иерархии.

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

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

2 ВЫПОЛНЕНИЕ РАБОТЫ

В работе требуется внимательно рассмотреть и разобрать приведенные примеры.

3 ФОРМА ОТЧЕТА

Отчет должен содержать ответы на вопросы.

4 КОНТРОЛЬНЫЕ ВОПРОСЫ

1. Дать определение абстракции.

2. Что такое класс? Объясните различие терминов класс и объект.

3. Для чего используются абстрактные модели?

4. Дать определение понятию «инкапсуляция»

5. Дать определение понятию «методы»

6. Формат записи класса

7. Объясните решение данного в работе упражнения

8. Дать определение понятию «модульность»

9. Дать определение понятию «иерархия». Определить ее виды.

Практическая работа № 7

Полиморфизм. Полиморфные объекты.

Цель работы: ознакомиться с понятием ООП полиморфизм.

1 ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ

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

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

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

Совокупность полиморфных методов с одним именем для иерархии классов образует единый полиморфный метод иерархии, в котором реализация полиморфного метода для конкретного класса представляет отдельный аспект.

Сложный полиморфизм. Полиморфными объектами, или по­лиморфными переменными, называются переменные, которым в процессе выполнения программы может быть присвоено зна­чение, тип которого отличается от типа переменной.

В языках со строгой типизацией такая ситуация может возникнуть:

при передаче объекта типа класса-потомка в качестве фак­тического параметра подпрограмме, в которой этот пара­метр описан как параметр типа класса-родителя (явно - в списке параметров или неявно - в качестве внутреннего параметра, используемого при вызове методов - Self);

при работе с указателями, когда на объект класса-родителя присваивается адрес объекта класса-потомка.

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

С помощью механизма позднего связывания реализуется опе­ративная перестройка программы в соответствии с типами ис­пользуемых объектов.

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

Формирование связи между экземпляром класса (объектом) и ТВМ осуществляет конструктор.

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

Итак, мы смогли исключить метод Move из описания класса TCircle, сделав его полиморфным. Все объекты классов TPoint и TCircle будут использовать его, причем так, как им это необ­ходимо.

Сформулируем правила, которые важно выполнять при ра­боте с виртуальными методами:

если в некотором классе метод описан как виртуальный, то все производные классы, включающие метод с тем же именем, должны описать этот метод как полиморфный (override). Нельзя заменить виртуальный метод статиче­ским;

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

В дополнении к виртуальным методам, для реализации по­лиморфизма в Object Pascal используются динамические мето­ды. По возможностям наследования и перекрытия они анало­гичны виртуальным методам, но доступ к ним выполняется через таблицу динамических методов (ТДМ). ТДМ хранит адре­са только тех динамических методов, которые определены в данном классе. Такой подход позволяет снизить расход памяти при большом количестве этих методов и самих классов.

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

Для объявления метода динамическим используется дирек­тива dynamic. Перекрытие динамических методов производит­ся так же, как и виртуальных - с использованием ключевого слова override.

Абстрактные методы

Абстрактные методы используются при объявлении мето­дов, реализация которых откладывается. Такие методы в клас­се описываются служебным словом abstract и обязательно пере­определяются в потомках класса.

Класс, в состав которого входят методы с отложенной реали­зацией, называется абстрактным. Создавать объекты абстракт­ных классов запрещается.

Упражнение 2 Разработайте родительский класс для ри­сования геометрических фигур.

Решение

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

Скрыть;

Задать новое расположение геометрической фигуры;

Отобразить;

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

Параллелизм - свойство нескольких абстракций одновре­менно находиться в активном состоянии, т. е. выполнять неко­торые операции.

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

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

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

Любой программный объект существует в памяти и живет в течение некоторого времени. Спектр сохраняемости объектов охватывает:

временные объекты, хранящие промежуточные результа­ты вычисления выражений;

локальные объекты, существующие внутри подпрограмм, время жизни которых исчисляется от вызова подпрограм­мы до ее завершения;

глобальные объекты, существующие, пока программа за­гружена в память;

сохраняемые данные, которые сохраняются в файлах внеш­ней памяти между сеансами выполнения программы.

Композиция и наполнение

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

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

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

Включение объектов в некоторый класс можно реализовать и с использованием указателей на объекты.

2 ВЫПОЛНЕНИЕ РАБОТЫ

В работе требуется внимательно рассмотреть и разобрать приведенные примеры.

3 ФОРМА ОТЧЕТА

Отчет должен содержать ответы на вопросы.

4 КОНТРОЛЬНЫЕ ВОПРОСЫ

1. Перечислите этапы объектной декомпозиции.

2. Что такое полиморфизм? Приведите пример, демонстрирующий не­обходимость определения полиморфного метода.

3. Простой полиморфизм.

4. Статический полиморфный метод.

5. Сложный полиморфизм.

6. Таблица виртуальных методов.

7. Параллелизм.

8. Процесс, сохраняемость.

9. В чем сходство и отличие методов, описанных как виртуальные и ди­намические?

10. Для чего используются абстрактные методы?

11. Композиция и наполнение.

Практическая работа № 8

Изучение интегрированной среды разработчика.

Цель работы: ознакомиться с интегрированной средой программы.

1 ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ

Во времена DOS, которые уже стали историей, программи­сты стояли перед нелегким выбором между продуктивным, но неэффективным Basic и эффективным, но непродуктивным ас­семблером. Появление компилятора Turbo Pascal во многом разрешило их проблемы. Программисты, работающие под Windows 3.1, оказались перед схожей проблемой: что вы­брать- мощный, но требующий знаний C++, или простой, но крайне ограниченный Visual Basic (VB). С появлением в 1995 г. Delphi 1 возник новый подход к разработке приложений в среде Windows: простой язык, визуальная разработка приложений, со­здание откомпилированных выполняемых файлов, динамических библиотек и многое другое. Delphi 1 был первым инструментом разработки Windows-приложений, объединившим в себе оптими­зирующий компилятор, визуальную среду программирования и мощные возможности для работы с базами данных.

В 1996 г. появилась версия Delphi 2, предназначенная для разработки приложений для 32-разрядных операционных систем Windows 95 или Windows NT.

Delphi 3 вышла в 1997 г. В этой версии Delphi был расширен набор инструментов для разработки Windows-приложений, упро­щено использование таких технологий, как ActiveX и СОМ, поддержка баз данных с многоуровневой архитектурой.

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

Выход версии Delphi 5 в свет состоялся во второй половине 1999 г. Ее характеризуют:

□ улучшение графической среды разработки и отладчика, пакет поддержки групповой разработки программ и инст­рументы трансляции;

набор новых функций, предназначенных для упрощения разработки приложений для Internet;

стабильность работы системы.

2.2. Основные элементы среды программирования Delphi

Для того чтобы запустить Delphi, выполните команду: Пуск - Программы - Borland Delphi 5 - Delphi 5 (рис. 2.2.1).

В интегрированную среду разработки Delphi входит несколь­ко основных элементов.

Главное окно Delphi. Главное окно Delphi содержит главное меню, панель быстрого доступа и палитру компонентов.

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

Палитра компонентов содержит пиктограммы, которые пред­ставляют компоненты библиотеки визуальных компонент (VCL).

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

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

Комбинированная панель выбора объекта - это поле, распо­ложенное вверху окна инспектора объектов. На рис. в комбинированной панели указан объект Forml: TForml.

Страница свойств (Properties). Для каждого компонента опре­делен список свойств, изменение которых приводит к измене­нию внешнего вида объекта или к изменению реакции на внеш­ние воздействия. Левая колонка страницы свойств содержит имена свойств, а правая - их значения.

Страница событий (Events). Каждый компонент способен ре­агировать на события, список которых отображен на странице событий инспектора объектов. Левая колонка страницы собы­тий содержит названия, а правая - имя процедуры-обработчи­ка события.

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

Окно редактирования модуля. Содержит текст модуля на языке Object Pascal, связанный с каждой формой приложения. Delphi автоматически создает этот программный код. Это окно также используется для редактирования других модулей при­ложения.

2.3. Создание приложения

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

2.3.1. Сохранение приложения

Выберите команду File - Save All.

В появившемся диалоговом окне сохранения файла создайте новую папку Exercise 1, в котором будут храниться файлы пер­вого проекта, созданного в Delphi. В строке Имя файла введите имя Main. Щелкните на кнопке Сохранить для сохранения фай­ла модуля, Main.pas (рис. 2.3.1.1), и файла формы, Main.dfm.

Создать папку

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

Затем Delphi с помощью еще одного диалогового окна сохра­нения файла запросит имя проекта. В строке Имя файла введи­те Exercisel и выберите Сохранить. Вы создадите файл проек­та - Exercisel. dpr.

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

2.3.2. Запуск приложения

Выберите команду Run из меню Run или щелкните на кноп­ке Run панели быстрого доступа.

Обратите внимание на внешний вид формы. Вовремя вы­полнения приложения исчезла точечная сетка, отображаемая в процессе проектирования. Курсор мыши имеет вид стрелки.

Закройте приложение, для этого щелкните дважды на кнопке системного меню в верхнем левом углу окна или на кнопке за­крытия окна, расположенной в верхнем правом углу. Если Вы привыкли работать с клавиатурой, то для закрытия приложения и возврата в среду программирования Delphi нажмите AIt+F4.

Если случайно приложение осталось открытым, многие команды Delphi будут недоступными (например, окно инспекто­ра объектов).

2 ВЫПОЛНЕНИЕ РАБОТЫ

В работе требуется внимательно рассмотреть и разобрать приведенные примеры.

Практическая работа № 9

Изменение свойств и событий.

Цель работы: ознакомиться с интегрированной средой программы.

1 ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ

Свойства влияют на то, как объект выглядит, и на его неви­димые черты (поведение).

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

Свойство Name. В Delphi для каждого объекта имеется свой­ство Name. Когда компонент помещается в форму, Delphi авто­матически присваивает ему уникальное имя. Наш компонент форма имеет имя Forml.

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

Назовем форму MainF (описана в модуле Main, буква F гово­рит о том, что данный объект - это форма (Form)). В окне инс­пектора объектов выберите свойство Name и в правом столбце наберите MainF. Это изменение сразу же отображается в комби­нированной панели выбора объекта инспектора объектов.

Свойство Color определяет цвет. В Delphi предусмотрены предопределенные цветовые константы, которые соответствуют многим общеупотребительным цветам. Например, при выборе констант clRed или clYellow цвет формы изменяется соответст­венно, на красный или желтый. Кроме того, определены кон­станты для представления системных цветов экранных элементов Win32. Например, константы clActiveCaption и clHighLightText соответствуют цветам активных заголовков и выделенного цве­та в Win32.

Установите цвет формы равным clGreen.

Свойство Caption определяет заголовок формы. Измените значение этого свойства на значение - Мое первое приложение.

Свойства Height и ClientHeight задают высоту формы и высо­ту рабочей области (исключая рамку и заголовок формы) соответ­ственно. Эти свойства связаны между собой: при изменении значения одного из свойств изменяется и другое. Свойства Width и UientWidth задают ширину формы и ширину рабочей области формы (исключая рамку формы) соответственно. Значения этих четырех свойств можно задать, уменьшая (или увеличивая) раз­меры формы, используя манипулятор мышь или вводя необходи­мые значения в правый столбец инспектора объектов.

Свойства Тор и Left определяют расположение формы на эк­ране, задавая расстояние от верхней границы экрана до верхне­го края формы и от левой границы экрана до левого края формы соответственно.

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

Свойство Cursor определяет графический вид курсора В инспекторе объектов измените свойство Cursor, выбрав из списка любое значение. Запустите приложение, посмотрите, как изменился вид курсора. Значение свойства Cursor, равное crtielp, придает курсору вид стрелки со знаком вопроса. За­кроите приложение.

Используя свойства Hint и ShowHint, можно отобразить подсказку. Установите значение свойства Hint в «Это форма» а значение ShowHint - в True. Запустите приложение Окно подсказки появляется, когда курсор мыши помещается на фор­му и на мгновение останавливается. Закройте приложение.

Обработка событий

Архитектуру программы, выполняющейся в операционной системе Windows, достаточно сложно нарисовать в виде визуа­льной схемы. Например, пусть программа только что начала работать. На экране показывается главное меню программы и пользователь нажимает на кнопку мыши. Нажатие на кнопку мыши является событием, начинает работать определенный объект. Пользователь мог бы не нажимать кнопку мыши, и тог­да работа программы пошла бы по другому сценарию. То есть ситуация типа: может быть, а может и не быть.

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

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

События делятся на три основные категории: события мыши, события клавиатуры и системные события.

Изменение свойств. 1. События мыши

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

Упражнение 1. Напишите приложение, которое при на­жатии левой кнопки мыши перекрашивает форму в красный цвет.

Решение

Создайте обработчик события OnClick: выберите страницу Events инспектора объектов и выполните двойной щелчок мы­шью в правой колонке, напротив события OnClick. На переднем плане появится окно редактирования модуля с помещенной сразу в нужное место модуля заготовкой обработчика события OnClick.

В обработчике события указан параметр Sender, в котором хранится имя объекта, породившего данное событие (в примере Sender будет содержать ссылку на объект MainF - форму).

Для изменения цвета формы в обработчике события OnClick напишем следующий оператор:

procedure TMainF.FormClick(Sender: TObject); begin

MainF.Color := clRed (*)

end;

Поясним оператор (*). MainF - это название объекта фор­мы. Color - это свойство формы. Обращение к свойствам объ­екта происходит так же, как и в структуре данных записи, че­рез точку.

Эксперимент. Запустите приложение. Щелкните левой кноп­кой мыши на форме. Убедитесь, что цвет формы стал красным.

Что произойдет при повторном щелчке левой кнопкой мыши на форме? Возникнет событие OnClick, в результате которого вы­полнится оператор (*), т. е. цвет формы остается красным. ♦

2. События клавиатуры

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

Событие OnKeyDown происходит при нажатии любой клави­ши, включая функциональные и специальные:

procedure TForml.FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);

Событие OnKeyPress возникает при нажатии клавиши, гене­рирующей символы ASCII, включая управляющие клавиши:

procedure TForml.FormKeyPress(Sender: TObject; var Key: Char);

Событие OnKeyUp происходит при освобождении любой кла­виши:

procedure TForml.FormKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);

Каждый из обработчиков событий получает по крайней мере, один параметр, называемый Key, который представляет нажа­тую клавишу, В обработчиках событий OnKeyDown и OnKeyUp параметр Key является беззнаковым значением типа Word, ко­торое представляет код виртуальной клавиши Windows. В об­работчике события OnKeyPress параметр Key - это значение типа Char, представляющее символ ASCII. Несмотря на то, что обе переменные называются Key, они представляют различную информацию. Все ASCII-символы имеют соответствующие коды виртуальных клавиш, но многие виртуальные клавиши не име­ют ASCII-эквивалента, например клавиша F1.

Упражнение 2. Напишите приложение, закрывающе­еся при одновременном нажатии клавиш Alt и X.

Решение

Создайте новое приложение и сохраните его в папке Exerci-se6. Файл модуля - под именем Main,pas, файл проекта - Exercise6.dpr.

Измените значения свойств формы следующим образом:

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

Воспользуемся значением параметра Shift для определения нажатия клавиши Alt:

if ssAlt in Shift then Close;

{Close - это метод формы, закрывающий ее}

Эксперимент. Убедитесь, что нажатие клавиши Alt приве­дет к закрытию формы. ♦

Определим код клавиши X. Добавьте в обработчик события OnKeyDown оператор:

Caption:=IntToStr(Key) ;

Здесь IntToStr(x) - это функция, которая преобразует целое число х в значение строкового типа, Key - код нажатой клави­ши.

Эксперимент. Запустите приложение. Определите виртуа­льный код клавиши с латинской буквой «х». ♦

Итак, виртуальный код клавиши с латинской буквой «х» равен 88. Для решения задачи напишем следующий код обра­ботчика события OnKeyDown формы:

procedure TMainF.FormKeyDown(Sender: TObject; var Key:

Word; Shift: TShiftState);

begin

if (ssAlt in Shift) and (Key=88) then Close; end;

Эксперимент. Сохраните приложение. Убедитесь, что при одновременном нажатии клавиш Alt и латинской буквы «х» независимо от выбранного языка приложение закрывается. Объ­ясните это. ♦

3. Системные события. Отладка приложения: точки прерывания

События мыши и клавиатуры вызываются воздействиями пользователя на программу. Системные события исходят непо­средственно от Windows.

Событие OnCreate наступает, когда форма создается.

Событие OnShow происходит, когда форма отображается (показана).

Событие OnActive происходит, когда форма становится ак­тивным окном программы (событие генерируется при получе­нии формой фокуса ввода. Это происходит, когда пользователь возвращается в форму из другой формы того же приложения).

Событие OnPaint происходит, когда форму необходимо ото­бразить заново (перерисовать).

Событие OnResize происходит, когда размеры формы изме­няются.

2 ВЫПОЛНЕНИЕ РАБОТЫ

В работе требуется внимательно рассмотреть и разобрать приведенные примеры и упражнения.

3 ФОРМА ОТЧЕТА

Отчет должен содержать ответы на вопросы и порядок выполнения данных упражнений.

4 КОНТРОЛЬНЫЕ ВОПРОСЫ

1. Каким образом можно изменить свойства компонента?

2. Перечислите основные свойства объектов программы.

3. В чем отличие программы, работающей в системе DOS, от програм­мы, работающей в системе Windows?

4. Какие события формы Вы знаете?

5. В каком порядке выполняются события клавиатуры: OnKeyPress, OnKeyUp, OnKeyDown?

6. Благодаря какому классу языка программирования Object Pascal воз­можна работа с графикой в Delphi? Перечислите свойства и методы этого класса.

7. Какие события происходят при создании формы и в какой последо­вательности?

8. Какие события происходят при закрытии формы и в какой последо­вательности?

Практическая работа № 10

Файлы, составляющие приложения Delphi

Цель работы: ознакомиться с интегрированной средой программы.

1 ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ

Приложение Delphi хранится в нескольких различных фай­лах. Каждое имя файла заканчивается расширением, которое определяет содержимое файла.

Для исследования файлов, составляющих проект Delphi, рассмотрим файлы первого созданного приложения. Запустите Delphi. Откройте файл проекта Exercise 1, для этого выполните последовательность команд:

File - Open Project... В диалоговом окне открытия файла выделите файл Exercisel. Щелкните на кнопке Open.

View - Units и затем из списка модулей появившегося диа­логового окна выберите все файлы. Щелкните на кнопке ОК. В окне редактирования модуля отображается два файла. Чтобы выбрать тот или иной, необходимо щелкнуть на соответствую­щей закладке в верхней части окна.

1. Файл проекта (.dpr)

Файл проекта представляет собой программу, написанную на языке Object Pascal. Эта программа автоматически созда­ется Delphi. Главный файл проекта изначально называется Projectl.dpr. Каждое приложение имеет единственный файл проекта. Проект Delphi является Pascal-программой. Проект имеет, по крайней мере, два назначения - объявить модули приложения и запустить приложение. Delphi автоматически создает исходный код файла проекта и управляет им. Вам ред­ко придется модифицировать операторы этого файла.

Рассмотрим структуру файла проекта Exercisel.dpr.

program Exercisel;

uses

Forms,

Main in 'Main.pas' {MainF};

{$R *.RES}

begin

Application.Initialize;

Application . CreateForm (TMainF, MainF) ,• Application.Run; end.

В первой строке файла содержится имя проекта - Exercise 1. Затем в объявлении uses определяются модули, используемые этой программой. В данном случае существует два таких моду­ля - стандартный модуль Forms, который обеспечивает воз­можности форм Delphi, а также модуль Main. Вторая строка объявления uses означает, что модуль Main расположен в фай­ле Main.pas, a MainF - это имя объекта формы, описанной в этом модуле.

Директива {$R *.RES} является указанием компилятору на необходимость подключения к программе файла ресурсов. Обыч­но файлы ресурсов содержат только пиктограмму программы, хотя, конечно, они могут иметь и другие типы ресурсов.

И, наконец, файл проекта завершается тремя операторами, расположенными между ключевыми полями begin...end. Каж­дый из них реализует обращение к одному из методов объекта Application. В объекте Application собраны данные и подпрограм­мы, необходимые для нормального функционирования Windows-программы в целом. Delphi автоматически создает объект-про­грамму Application для каждого нового проекта.

Для того чтобы создать конкретное Windows-приложение с помощью Object Pascal, необходимо создать объект-потомок TApplication. Методы и свойства, описанные в TApplication, осу­ществляют создание, выполнение, поддержку и разрушение при­ложения. Во время написания Windows-приложения TApplication является посредником между программистом и окружением Windows.

Метод Initialize - первый метод, вызываемый для каждого проекта Delphi, - осуществляет ряд вспомогательных дейст­вий, необходимых для работы под управлением операционной системы Windows.

Метод CreateForm создает новую форму, тип которой описан в параметре FormClass, и связывает ее с переменной, указанной параметром Reference:

procedure CreateForm(FormClass: TFormClass; var Reference);

По умолчанию форма, созданная первым вызовом FormCreate, становится главной формой приложения.

Метод Run выполняет приложение. Этот метод содержит цикл обработки сообщений и не прекращает свою работу, пока цикл обработки сообщений не закончен (т. е. реализует беско­нечный цикл получения и обработки поступающих от Windows сообщений о действиях пользователя. Когда пользователь щел­кнет на кнопке Close, Windows передаст программе специаль­ное сообщение, которое в конечном счете заставит программу прекратить работу и освободить назначенные ей системные ре­сурсы).

Кроме этих трех методов в классе TApplication описаны мно­гие другие полезные методы и свойства, необходимые при со­здании проекта.

Некоторые свойства класса TApplication:

ExeName HintHidePause Icon

Hint HintPause ShowHint

HintColor HintShortPause Title

Некоторые методы класса TApplication:

BringToFront Minimize MessageBox Restore

2. Файл модуля (.pas)

Модули - это программные единицы, предназначенные для размещения фрагментов программ. С помощью содержащегося в них программного кода реализуется вся поведенческая сторо­на программы. Эти файлы содержат исходный код приложения на языке Object Pascal. В типичном приложении Delphi для каждой формы создается один файл с расширением pas:

unit Main; interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

type

TMainF = class(TForm) procedure FormClick(Sender: TObject);

private { Private declarations }

public { Public declarations }

end;

var

MainF: TMainF;

implementation

{$R *.DFM}

procedure TMainF.FormClick(Sender: TObject); begin

Color:=clRed end;

end.

В первой строке Main.pas указывается имя модуля - Main. Delphi присваивает модулю то имя, которое указывается при сохранении файла модуля проекта.

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

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

Модуль Main использует много различных модулей, все они представлены в операторе uses. Такие модули, как Windows и Messages, обеспечивают необходимые данные и программный код для интерфейса прикладных программ Windows, а модули Classes, Graphics, Controls - для формы, компонентов и дру­гих элементов программы.

Далее идет раздел объявления типов, определяемый ключе­вым словом type. Тип TMainF задает описание класса (class). Класс TMainF в Main.pas наследует члены класса TForm, кото­рый поддерживает в Delphi функциональные возможности фор­мы. Таким образом, класс TMainF является потомком класса TForm.

Класс TMainF объявляет процедуру FormClick(Sender: TObject), которая обрабатывает действие - щелчок мышью на форме.

Классы могут иметь дополнительные объявления, которые бывают либо собственными (private), либо общедоступными (public), т. е. доступны также операторам других модулей.

Завершает раздел интерфейса описание переменных, предва­ряемое словом var. Модули могут содержать одну или несколь­ко переменных, но могут обходиться и без них. В модуле Main - только одна переменная:

var MainF: TMainF;

Эта строка объявляет объект-переменную MainF класса TMainF, т. е. MainF - это занимающий определенный участок памяти экземпляр класса. В этом примере объект представляет собой главное окно программы, которая содержит обработчик события, выполняющий действия при щелчке на форме.

За разделом интерфейса идет раздел реализации (implemen­tation), в котором описаны элементы, скрытые от пользовате­ля. Этот раздел может также содержать разделы подключения модулей, описание типов, переменных, констант, кроме этого он содержит программный код подпрограмм, указанных в ин­терфейсной части модуля. К элементам, указанным только в разделе implementation, запрещены обращения из других моду­лей, использующих данный модуль.

Первая строка раздела implementation содержит директиву

{$R *.DFM}

которая открывает и читает файл с расширением .DFM. Звез­дочка указывает Delphi на необходимость поиска файла с име­нем, совпадающим с названием файла модуля, но имеющим расширение .DFM. Этот файл содержит свойства формы, изме­ненные с помощью окна Object Inspector.

В последней строке файла находится ключевое слово end, за которым следует точка.

Итак, в секции интерфейсных объявлений описываются про­граммные элементы, которые будут «видны» другим програм­мным модулям, а в секции реализаций раскрывается механизм работы этих элементов. Разделение модуля на две секции обес­печивает удобный механизм обмена алгоритмами между отдель­ными частями одной программы. Он также реализует средство обмена программными разработками между отдельными про­граммистами. Получив откомпилированный «посторонний» модуль, программист получает доступ только к интерфейсной час­ти, в которой, как уже говорилось, содержатся объявления элементов. Детали реализации объявленных процедур, функ­ций и классов скрыты в секции реализаций и недоступны дру­гим модулям.

3. Файл формы (.DFM)

Файл формы используется для сохранения информации о внешнем виде главной формы, содержит значения в двоичном формате, представляющие свойства формы, а также свойства любых компонент, находящихся на форме. В файлах .DFM так­же фиксируются взаимоотношения между событиями и обра­ботчиками событий. Delphi копирует эту информацию в испол­няемый Ехе-файл. Чтобы посмотреть информацию файла формы в текстовом виде, выполните команду View as Text контекстно­го меню формы:

object MainF: TMainF

Left = 200

Top = 108

Width = 544

Height = 375

Hint = 'Это форма'

Caption = 'Мое первое приложение1

Color = clYellow

Font.Charset = DEFAULT_CHARSET

Font.Color = clWindowText

Font.Height = -11

Font.Name = 'MS Sans Serif

Font.Style = []

ShowHint = True

OnClick = FormClick

PixelsPerlnch = 96

TextHeight = 13 end;

Чтобы вернуться к графическому режиму отображения фор­мы, выполните команду View as Form контекстного меню.

4. Дополнительные файлы приложения Delphi

Мы рассмотрели основные файлы проекта. Рассмотрим до­полнительные файлы, создаваемые Delphi. Используя Провод­ник Windows, откройте папку Exercisel.

Файл .DCU содержит скомпилированный код модуля. На­пример, файл main.dcu содержит программный код и данные, объявленные в модуле main.pas. Вы можете безо всякого риска удалять файлы .dcu, поскольку Delphi создаст их снова при компиляции приложения.

Файл .RES. Файл ресурсов содержит в двоичном формате та­кие ресурсы, как пиктограмма программы и другие растровые изображения. Для того чтобы создавать и модифицировать файлы ресурсов, воспользуйтесь командой Image Editor меню Tools. Никогда не вносите изменений в файл ресурсов проекта, имя которого совпадает с именем проекта, но заканчивается расширением .RES. При перекомпиляции Delphi все внесенные вами ресурсы исчезнут.

Файл .DSK сохраняют конфигурацию рабочей области при­ложения, если включен режим Desktop AutoSave с помощью команды environment меню option. Файлы .DSK сохраняют ин­формацию об окнах Delphi и порядке их расположения, а так­же каталоги хранения файлов проекта. Файлы .DSK сохраняют также маршруты проекта, поэтому если вы переносите свои проекты в другие папки или сохраняете модули проекта в не­скольких папках, то не следует удалять файлы .dsk.

Файл .DOF сохраняет параметры, установленные с помощью команды Option... меню Project. Содержание файла - текущие установки проекта, такие, как параметры компилятора, коман­дной строки, директории и другие. Если вы удалите файл с рас­ширением dof, Delphi создаст его снова, используя работающие по умолчанию параметры. Будьте осторожны при удалении файла опций проекта, так как могут возникнуть проблемы для приложений с нестандартной настройкой.

Эксперимент. Используя диалоговое окно Project Options, измените иконку приложения, отображаемую в Проводнике Windows; внесите информацию о названии компании, описание файла, комментарии. Проследите изменения в файле опций. Для создания иконки воспользуйтесь программой Image Editor, поставляемой вместе с Delphi. ♦

Исполняемый файл (.ЕХЕ). Файлы, заканчивающиеся на .-*, являются резервными копиями модифицированных или сохраняемых файлов. Можно спокойно удалять эти файлы в любое время, хотя они могут понадобиться, чтобы восстановить потерянные или разрушенные программы или вернуться к пре­дыдущим версиям.

2 ВЫПОЛНЕНИЕ РАБОТЫ

В работе требуется внимательно рассмотреть и разобрать построчно приведенные примеры. Оформить отчет.

3 ФОРМА ОТЧЕТА

Отчет должен содержать ответы на вопросы и результаты эксперемента.

4 КОНТРОЛЬНЫЕ ВОПРОСЫ

1. Какие файлы составляют проект Delphi? Какие файлы проекта нель­зя удалять ни в коем случае? Объясните.

2. Объект Application. Для чего он предназначен? Перечислите основ­ные свойства и методы этого объекта.

3. Опишите общую структуру модуля в Object Pascal.

4. Каким образом обеспечивается сокрытие информации при описании класса?

5. Для чего предназначен файл формы?

Практическая работа №11.

Создание простейшего Windows-приложения

Цели работы: Создание простейшего Windows-приложения с заданным заголовком окна и цветом формы

1. Создать папку для сохранения разработанных приложений

2. Запустить Delphi

3. Изменить заголовок окна формы с Form1 на Привет: в окне инспектора объектов (Object Inspector) установить для свойства Caption значение Привет

4. Изменить цвет формы со стандартного на другой: в окне инспектора объектов установить для свойства Color значение clAqua.

5. Выполнить приложение:

   1. Запустить приложение - меню Run, Run или F9 или кнопка на панели инструментов.

   2. Изменить размеры окна.

   3. Поэкспериментировать со стандартными кнопками минимизации и максимизации окна.

   4. Закончить работу приложения, закрыв его окно.

6. Сохранить форму и проект на диске:

Меню File, Save All, установить свою папку, создать новую папку (с именем Лабораторная работа №1), открыть ее, ввести имя проекта.

Практическая работа №12

Моя первая программа

Цели работы: Создание Windows-приложения, которое содержит текст "Моя первая программа!" и кнопки, позволяющие изменять размер шрифта и двигать текст

1. Поместить объект Label в окно формы Form1:

2. Переместить объект Label1 на желаемое место в форме.

3. Изменить свойства объекта Label1:

В окне инспектора объектов (Object Inspector) установить следующие значения для свойств объекта:

Объект

Свойство

Значение

Label1

Caption

Моя первая программа!

Font

12 p., красный

Alignment

TaCenter

Color

Желтый (Yellow)

AutoSize

False

4. Выполнить приложение: меню Run, Run или F9.

5. Сохранить форму и проект на диске: Меню File, Save All, установить свою папку, ввести имя Лабораторная работа №2.

6. Поместить объект Button (командная кнопка) в окно Form1. Он по умолчанию получит имя Button1. Изменить его размеры.

7. Установить свойство Caption объекта Button1 в значение "Увеличение".

8. Написать код для события Click на объекте Button1: Два раза щелкнуть по объекту Button1 в форме Между словами Begin и End написать следующий

код: Label1.Font.Size := Label1.Font.Size +2;

9. Выполнить программу. Обратить внимание на то, что происходит при нажатии кнопки с надписью "Увеличение".

10. Сохранить форму и проект на диске: Меню File, Save.

11. Создать объект "командная кнопка" для уменьшения размера шрифта в тексте.

12. Создать объект "командная кнопка" для того, чтобы двигать текст.

Код: Label1.Left := Label1.Left + 10;

Label1.Top := Label1.Top + 10;

13. Создать объект "командная кнопка" для того, чтобы сделать текст невидимым.

Код: Label1.visible := false;

14. Создать объект "командная кнопка" для выхода из работы программы.

Код: Close;

15. Сохранить форму и проект.

Практическая работа № 13.

Простейшая математическая программа

Цели работы: Целью работы является практическое освоение методологии и принципов создания базовых стандартных элементов интерфейса Windows-программы в среде визуального проектирования.

В представленном ниже проекте используем следующий минимальный набор компонент.

Button - стандартная кнопка, обычно кнопка используется для запуска действия, при этом задействуют только метод OnEvent (реакция на нажатие). Свойство Default=True ассоциирует вводимый компонент с кнопкой Enter, Cancel=True - с кнопкой Esc. Свойства Color для оформления надписи (Caption) у кнопки нет. Амперсант, помещенный в тексте надписи, указывает быструю Alt-клавишу запуска, например, Caption=A&Ppend вызывает срабатывание кнопки при нажатии Alt-P. Свойство ModalResult=true определит обязательность нажатия для закрытия дочернего окна.

Label - метка, используется как надпись или как область вывода информации для чтения. Как и для кнопки, для метки можно определить клавишу быстрого доступа, но она будет запускать связанный с меткой компонент (по FocusControl). Свойство AutoSize=True определит минимизацию размера метки под текст надписи, Aligment - центровку этого текста, WordWrap - возможность расположения текста в несколько строк, Transparent - прозрачность при наложении на другие элементы.

Edit - строка ввода. Заголовка (Caption) у этого компонента нет, но есть свойство Text как содержимое строки. Это свойство можно как считывать, так и присваивать (при необходимости с ограничением длины назначением свойства MaxLength). При вводе конфиденциальной информации указывают отображаемые символы (обычно "*"), при этом нужно переопределить свойство PasswordChar, задав его отличным от #0.

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

При этом на форме нужно разместить четыре надписи (с задаваемыми свойствами Caption) и пятую надпись с пустой Caption - для отображения суммы. Определить две строки ввода для суммируемых чисел (против меток "первое" и "второе") и одну кнопку "Расчет" для запуска процедуры суммирования после ввода чисел.

После двойного щелчка на кнопке можно заполнить шаблон процедуры реакции на нажатие этой кнопки (рамкой выделен вводимый текст).

procedure TForm1.Button1Click(Sender: TObject);

var a,b,c: real;

s: string; code: integer;

begin

{ввод данных из полей редактирования}

val(edit1.text,a,code);

val(edit2.text,b,code); c:=a+b;

str(c:-10:4,s); {перевод числа в строку}

label5.Caption:=s

end;

Практическая работа №14.

Элементы оформления проекта

Цели работы: Целью работы является практическое освоение методологии и принципов создания и оформления элементов интерфейса Windows-программы.

Приведенный выше вариант программы вполне работоспособен. Но в подобных программах обязательное требование в части их оформления - предусмотреть реакции на ввод символов в полях редактирования, например, защиту от ввода букв или второй десятичной точки. При нажатии Enter естественно переносить курсор в следующее поле редактирования или выполнять другие действия, если ввод данных завершен. В обработчиках событий (закладка Events инспектора событий Delphi) для полей ввода определим методы OnKeyPress, задав им имена, например, e1 и e2. Затем после двойного щелчка заполним шаблоны процедур.

procedure TForm1.e1(Sender: TObject; var Key: Char);
begin

{защита поля редактирования на ввод числа }

case key of

'0'..'9',chr(8):;

'.': if pos('.',edit1.text)>0 then key:=chr(0);

'-': if length( edit1.text)>0 then key:=chr(0);

chr(13): edit2.SetFocus;

else key:=chr(0);
end;

end;

Вторая процедура отличается от первой лишь реакцией на нажатие клавиши Enter

procedure TForm1.e2(Sender: TObject; var Key: Char);
begin

... edit2.text ...
chr(13): edit2.font.color:=clRed; ...

end;

Текст процедуры TForm1.Button1Click желательно оформить как самостоятельную процедуру, например, procedure Summa(edit1,edit2: tEdit; label5: TLabel);

и вызывать ее как внутри TForm1.Button1Click, так и в реакции на Enter в процедуре TForm1.e2, при этом окончание ввода данных сразу запустит вычисления.

Введем кнопку очистки полей ввода и вывода результата для нового расчета. Заголовок кнопки определим как Caption="новое", зададим реакцию OnClick (двойным щелчком на кнопке).

procedure TForm1.Button2Click(Sender: TObject);

begin

{очистка полей ввода}
edit1.text:='';
edit2.text:='';
label5.caption:='';
edit1.SetFocus

end;

Введем кнопку выхода

procedure TForm1.Button3Click(Sender: TObject);

begin

form1.close { завершение приложения}

end;

Практическая работа №15

Компоненты выбора и настройки параметров

Цели работы: Создание Windows-приложения, в котором при щелчке на радио-кнопке с названием цвета на светофоре загорается соответствующий цвет

Выбор и настройка параметров при работе с программным приложением считается стандартной частью работы пользователя с любым серьезным приложением. Это может быть как настройка самого приложения, так и определение параметров отображаемых или моделируемых в приложении процессов и явлений. Элементы интерфейса Windows-программы для основных операций такой работы в настоящее время практически стандартизированы. Рассмотрим создание этих элементов на примере работы с компонентами библиотеки VCL (Visual Component Library) в среде Delphi.

Базовые элементы выбора и настройки параметров расположены на странице Standart палитры компонент Delphi. В представленном ниже проекте используем следующий классический набор компонент:

GroupBox - группа, которая визуально и логически объединяет наборы компонент, определяет порядок перемещения по компонентам на форме (при нажатии клавиши TAB). При помещении в группу новый компонент получает свойства ParentColor, ParentShowHint, ParentFont, ParentCtl3D этой группы. Свойства Left и Top сгруппированных объектов определяются по верхнему углу группы, а не формы;

RadioGroup - группа для объектов RadioButton (см. ниже);

RadioButton - переключатели или радиокнопки, служат для выбора одной возможности из набора взаимоисключающих возможностей. Термин отражает сходство с набором кнопок выбора каналов радиоприемника. Эти кнопки обычно объединяют группой RadioGroup. Выбор кнопки отражает свойство Checked, свойство Alingment определяет положение поясняющей надписи относительно кнопки;

CheckBox - выключатель, выглядит как строка текста с окошком для установки отметки о выборе. Выключатели работают независимо, но их обычно группируют. При определении реакции на выбор можно использовать событие OnClick, но обычно устанавливают как индикатор свойство State по трем состояниям - cbChecked (есть), cbUnChecked (нет), cbGrayed (неопределенно) внутри программы. При этом для блокировки ручного изменения этого свойства нужно установить DragMode=Automatic.

Пример проекта с выбором параметров

1. Поместить компоненты Label, Panel, GroupBox, RadioButton (страница Standard) в форму.

2. Установить следующие свойства объектов, используя Инспектор объектов:

   Label1

   Caption

   Светофор

   Panel1,2,3

   Caption

   GroupBox1

   Caption

   Цвет

   RadioButton1

   Caption

   Красный

   RadioButton2

   Caption

   Желтый

   RadioButton3

   Caption

   Зеленый

   
   

3. Записать код для процедуры обработки события Click (щелчок мыши) на объекте RadioButton1:

procedure TForm1.RadioButton1Click(Sender: TObject);

begin

Panel1.Color := clRed;

Panel2.Color := clWhite;

Panel3.Color := clWhite;

end;

Самостоятельно записать код для процедур: TForm1.RadioButton2Click и TForm1.RadioButton3Click

4. Добавить печать информации "Стойте", "Внимание", "Идите" на панели с соответствующим сигналом белым цветом шрифта жирным начертанием 12п.

Практическая работа №16.

Создание Windows-приложения «Цифровые часы»

Цели работы: Создание Windows-приложения, в котором работают цифровые часы с разной скоростью

1. Поместить компоненты Label (вкладка Standard) и Timer (System) в форму Form1.

2. Установить следующие свойства объектов

Объект

Свойство

Значение

Form1

Label1

Label1

Label1

Label1

Name

Caption

Color

Font.Size

Font.Color

Clock

00:00:00 clYellow

24

Красный

3. Записать код обновления времени для процедуры TClock.Timer1Timer:

Label1.Caption:=TimeToStr(Time);

4. Добавление кнопок регулирования скорости обновления времени.

   1. Добавить в форму компоненты GroupBox и RadioButton:

   2. Установить следующие свойства объектов:

GroupBox1

Caption

Скорость

RadioButton1

Caption

Медленно

RadioButton2

Caption

Умеренно

RadioButton3

Caption

Быстро

4.3. Записать код для процедуры TForm1.RadioButton3Click: Timer1.Interval := 1000;

Самостоятельно записать код для процедур: TForm1.RadioButton1Click (3000) и

TForm1.RadioButton2Click (2000)

Практическая работа №17

Использование cписков

ListBox - обычный список, этот компонент предназначен для работы с перечнем текстовых элементов (с ограничением по количеству до ~5000 шт). Перечень можно создавать (в том числе загружать как строки из текстового файла), преобразовывать и выгружать в файл. Элементы списка могут быть выбраны с помощью клавиатуры или мыши. Классический пример использования ListBox в среде Windows - выбор файла из списка в пункте меню File/Open многих приложений.

Основное свойство списка - Items (массив строк), оно аналогично свойству Lines для компонента Memo. Индекс выбранного элемента списка хранится в переменной ItemIndex. Методы Add, Delete, Insert используются для добавления, удаления и вставки строк.

Свойство Sorted=True упорядочивает список по возрастанию кода символов строк. ItemHeight - вертикальный размер элементов, Columns - число колонок в списке, ExtendedSelect - возможность множественного выбора элементов (при удержании Shift), при этом для выбранных элементов свойство Selected[номер] равно True.

ComboBox - комбинированный список, дополнительно к обычному включает строку ввода. Из нескольких типов ComboBox наиболее популярен спадающий вниз (drop-down combo box).

Создадим типовой проект с компонентом ListBox

На форме (рисунок 3). кроме списка разместим ряд кнопок (или пунктов меню), а также две строки ввода Edit1, Edit2 и две метки Label1, Label2. По выбору пунктов организуем следующие операции со списком:

Загрузка строк из файла, имя которого предварительно набирается в строке ввода (пункт "файл")

Listbox1.Sorted:=false;

Listbox1.Items.LoadFromFile(Edit1.Text)

Сортировка списка (пункт "сортировать"):

Listbox1.Sorted:=true

Запись списка в файл, имя которого предварительно набирается в строке ввода (пункт "сохранить как"):

Listbox1.Items.SaveToFile(Edit2.Text);

MessageDlg('Создан файл '+Edit2.Text,mtInformation,[mbOK],0)

Загрузка списка экранных шрифтов (пункт "шрифт"):

Listbox1.Items:=Screen.Fonts

Добавление случайного числа в список с соблюдением сортировки, если она задана (пункт "добавить")

var s: string;

begin

str(random:10:8,s); { генерация случайного числа }

ListBox1.Items.Add(s) end;

Добавление числа в нужное место списка (пункт "вставить")

var s: string;

begin

str(random:10:8,s); { генерация случайного числа }

ListBox1.Items.Insert(ListBox1.ItemIndex,s);

end;

Удаление выбранного элемента списка (пункт "удалить")

ListBox1.Items.Delete(ListBox1.ItemIndex)

Выведем некоторые характеристики выбранного элемента на метках:

var code: integer; a: real;

begin

Label2.Caption:= ListBox1.Items[ListBox1.ItemIndex];

Val(Label2.Caption,a,code);

If code=0 then Label1.Caption :='число'

else Label1.Caption :='строка';

end;

Практическая работа №18

Создание приложения «Картинная галерея»

Цель работы: Создать Windows-приложение, в котором при нажатии по соответствующей кнопке появляется соответствующая картина.

1 ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ

Процедуры и функции преобразования данных

Компоненты Label, Edit и ряд других компонентов можно использовать для ввода и вывода данных. Обычно поля для отображения данных имеют тип String, поэтому при вводе и выводе числовых данных возникает проблема преобразования символьного представления числа в цифровую форму при вводе и преобразования цифрового представления числа в символьную форму при выводе. Для этого в Lazarus используются функции:

Функция FloatToStr(X) преобразует вещественное число X типа Extended в символьное представление (возвращает строку типа String).

Функция IntToStr(N) преобразует целое число N типа Integer в строку символов, содержащую символьное представление числа.

Функция StrToFloat(S) преобразует строку S типа String в двоичное вещественное число типа Extended.

Функция StrToInt(S) преобразует строку S в целое число типа Integer.

2 ОПИСАНИЕ ПЛАНА РАЗРАБОТКИ ПРОГРАММЫ

• Назовите Форму - Картинная галерея (свойство Caption). Сохраните Модуль под именем UnitPictures (File - Save as) в своей папке и там же сохраните Проект под именем ProjectPictures.

• В эту же папку скопируйте три изображения из папки Collection.

• На Форму поместите два компонента Panel (панель) со страницы Standard. В свойстве Caption (заголовок) для обеих панелей удалите текст.

• В первую панель поместите три кнопки BitBtn со страницы Additional. В свойстве Caption для кнопок запишите: Первая картина, Вторая картина, Третья картина:

• На вторую панель вставьте компонент Image со страницы Additional. Выделите компонет Image. Перейдите в Инспектор объектов в свойстов Picture, нажмите рядом на три точки. Выберите файл картинки. Когда она отобразится в вашей Форме, настройте ее размер и в свойстве Visible (видимость) выберите значение False. Это значит, что картинку не будет видно до тех пор, пока вы этого не захотите.

• Два раза щелкните по кнопке «Первая картина» в тело процедуры внесите следующий оператор:

begin

Form1.Image1.Visible:=true;

end;

• Сохраните и запустите Проект.

• Добавьте еще один компонент Image так, чтобы его размеры были такими же, как и у имеющегося уже объекта Image1, в свойстве Visible также выберите False.

• В тело процедуры для кнопки «Вторая картина» вставьте операторы:

begin

Form1.Image1.Visible:=false;

Form1.Image2.Visible:=true;

end;

• Процедура делает видимой вторую картину и невидимой - первую.

• Сохраните изменения и запустите Проект. Если щелкнуть по кнопке «Первая картина», то не увидите картинки. Для отображения картинки, в процедуру для первой кнопки следует добавить оператор:

Form1.Image2.Visible:= false;

• Вставьте в Проект третий компонент Image, подберите размер и установите необходимые параметры.

• Создайте процедуру для третьей кнопки.

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

• Теперь сделайте так, чтобы под каждой картинкой появлялась подпись. Для этого добавьте в Проект компонент Label (метка).

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

Form1.Label1.Caption:='Закат';

Form1.Label1.Visible:=true;

• Название укажите для своей картинки.

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

• Сохраните изменения и запустите проект.

Практическая работа №19

Создание приложения «Решение квадратного уравнения»

Цель работы: Создание Windows-приложения, в котором будет решаться квадратное уравнение стандартного вида ax2+bx+c=0.

Описание плана разработки программы

• Форма проекта должна иметь следующий вид:

• В заголовке Формы запишите: «Решение квадратного уравнения».

• Разместите на Форме необходимые объекты (Panel, Edit, Label, Button).

• Измените свойства объекта Label - «Уравнение корней не имеет», так чтобы при запуске проекта его не было видно.

• Сохраните Проект.

• Активизируйте модуль Проекта (F12).

• В разделе описания переменных var надо перечислить все переменные, которые будут использоваться в программе, и указать тип:

a, b, c, D, X1, X2:Real;

• В нашем случае все переменные одного типа - вещественные числа. Теперь эти переменные будут «видны» всей программе. Описание переменных можно производить и в каждой процедуре, где они используются.

• Теперь надо записать процедуру вычисления дискриминанта для кнопки «Вычислить»:

a:=StrToFloat (Edit1.Text);

b:= StrToFloat (Edit2.Text);

c:=StrToFloat (Edit3.Text);

D:=b*b-4*a*c;

Edit4.Text:=FloatToStr(D);

• Самостоятельно напишите процедуру для кнопки «Показать результат», Clear.

• Проверьте работу программы.

Практическая работа №20

Создание приложения «Программа-шутка»

Цели работы: Создание Windows-приложения, в котором изменяется расположения объектов.

1. Поместить компоненты Label и Button в форму в соответствии с рисунком

2. Установить следующие свойства объектов

Объект

Свойство

Значение

Form1

Caption

Шутка

Label1

Caption

?

Label1

Color

clMaroon

Label1

Font.Size

18

Label1

Font.Color

Синий

Label1

Alignment

taCenter

3. Установить свойство объекта Button2: DragMode dmAutomatic

4. Записать код для обработки события MouseMove на объекте Button2:

procedure TForm1.Button2MouseMove(Sender: TObject; Shift: TShiftState;

X,Y: Integer);

begin

Button2.Left := Button2.Left+10;

Button2.Top := Button2.Top+10;

end;

5. Записать код для обработки события Click на объекте Button1:

procedure TForm1.Button1Click(Sender: TObject);

begin

Label1.Caption := 'Мы были в этом уверены!'

end;

5. Выполнить программу.

6. Развитие задачи:

Изменить программу т.о., чтобы при подводе курсора мыши к кнопке Button2

кнопка исчезала, а при отводе курсора - появлялась.

Практическая работа №21

Работа с окнами диалога

Цели работы: Целью работы является практическое освоение методологии и принципов создания элементов диалога как стандартных компонент интерфейса Windows-программы.

Палитра компонент Delphi содержит закладку Dialogs - диалоги работы с текстовыми и графическими файлами (открытие и сохранение), выбор цвета и шрифта, поиск и замена, работа с принтером (рисунок 4).

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

Обычно окна диалога используются в солидных проектах с переработкой информации из файлов различных типов. Поэтому в качестве учебного примера создадим проект из двух форм - основной (Form1, свойство formStyle=fsMDIform) и дочерней (Form2, formStyle=fsMDIchild). Дочернюю форму введем из меню File/New form и затем добавим ее в проект.

На основной форме (рисунок 5) разместим кнопки "открыть", "сохранить", "сохранить как", "выход" и "графика", а также поле Memo с Aling=alRight. Здесь же поместим три диалога - два OpenDialog (один для текста, второй - для графики) и один SaveDialog.

На дочерней форме разместим компонент Image (c закладки Additional) для вывода рисунков. Свойство Align=alClient определит заполнение по краям формы, а свойство Stretch - растяжку рисунка по границам.

Для кнопки "открыть" введем загрузку в поле примечаний содержимого файла

WITH OpenDialog1 Do
If Execute Then begin
Memo1.Visible:=True; { видимость поля редактора }
Memo1.Lines.LoadFromFile(FileName);
Caption:='Мой редактор '+
ExtractFileName(FileName);
SaveDialog1.Filename:=FileName;
FileName:='';

end;

Для кнопки "сохранить":

Memo1.Lines.SaveToFile(SaveDialog1.Filename)

Для кнопки "сохранить как":

WITH SaveDialog1 Do

If Execute Then begin

Memo1.Lines.SaveToFile(FileName);

Caption:='Мой редактор '+

ExtractFileName(FileName);

end;

Для кнопки "графика" зададим деактивацию поля Memo для освобождения пространства главной формы:

WITH OpenDialog2 Do
If Execute Then begin

Memo1.Visible:=False;

Screen.Cursor:=crHourglass; {курсор "песочные часы"}

WITH Form2.Image1.Picture Do

LoadFromFile(FileName);

Caption:= ExtractFileName(FileName);

Screen.Cursor:=crDefault; { нормальный курсор }

end;

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

Для нормальной работы диалоговых компонент необходимо определять свойство Filter (двойным щелчком в инспекторе объектов), например, для диалогов с текстовыми файлами обычно заполняют две строки "Текстовые файлы - *.txt" и "все файлы - *.*". Для графических файлов можно определить "Растры - *.bmp", "Пиктограммы - *.ico", "Метафайлы - *.wmf".

Практическая работа №22

Компоненты управления файлами

Цели работы: Практическое освоение методологии и принципов создания элементов управлениями файлов.

Описанные выше диалоговые панели работы с файлами общего назначения (тип OpenDialog и SaveDialog) часто несут избыточную информацию, например, когда требуется только список файлов текущего каталога или список логических устройств. В этом случае используют простые файловые компоненты с закладки Win3.1. Таких компонент здесь четыре:

FileListBox - список файлов указанного каталога;

DirectoryListBox - список каталогов указанного диска;

DriveComboBox - список логических устройств;

FilterComboBox - задание шаблона для FileListBox.

Приведем пример проекта работы с файлами с использованием простых файловых компонент.

Поместим перечисленные выше компоненты на форму вместе с компонентом Image (рисунок 6) для просмотра выбранных из списка файлов, содержащих графические изображения.

Свойство Filter шаблона файлов (FilterComboBox) определим при создании формы

procedure TForm1.FormCreate(Sender: TObject);

begin

FilterComboBox1.Filter:= 'метафайлы|*.wmf|'+'иконки|*.ico|'+'растры|*.bmp'

end;

Свойство DblClick для DirectoryListBox определяем как

FileListBox1.Directory:=DirectoryListBox1.Directory

Свойство OnChange для DriveComboBox (смена диска) определяем как

DirectoryListBox1.Drive:=DriveComboBox1.Drive;

FileListBox1.Directory:=DirectoryListBox1.Directory

Выбранный файл должен отображаться в области компонента Image1, поэтому в FileListBox на событие OnClick вводим

Image1.Picture.LoadFromFile(FileListBox1.FileName)

Практическая работа №23.

Работа с мультипликацией.

Цели работы: Практическое освоение методологии и принципов создания мультипликации и работа с видеоклмпами.

1. Создать в графическом редакторе Paint новый рисунок с размерами 500 на 100

пикселей. Вставив из файлов ХЛЕБА.BMP и ХЛЕБА 1.BMP рисунки, сформировать киноленту.

2. Разместить в форме панель c размерами 100х100.

5. Поместить компоненты Label, Button(вкладка Standard), OpenDialog (вкладка Dialogs) и Timer (System) в форму Form1.

3. Прямо на панель точно по левому краю разместить компонент IMAGE1 с размерами 500х100 и вставить на него киноленту.

4. Установить следующие свойства объектов

Объект

Свойство

Значение

Form1

Caption

Media Player

Label1

Caption

Label1

Alignment

TaLeftJustify

Button1

Caption

О&ткрыть

Button2

Caption

В&ыход

OpenDialog

Filter

Аудио файл (*.wav; *.mid)|*.wav; *.mid

RxGIFAnimator1

Animate

True

5. Поместить компоненты RxGIFAnimator(вкладка RX Controls) и в форму Form1.

6. Разместить в форме таймер с интервалом 250 и для события OnTimer записать код

With RxGIFAnimator1 do Begin

RxGIFAnimator1.;

Image1.Left := Image1.left + 10;

End;

5. Запустить и при успешной работе сохранить программу.

6. Разместить новую панель и компонент MediaPlayer1.

7. Записать код для обработки события Click на объекте Button1:

procedure TForm1.Button1Click(Sender: TObject);

begin

if OpenDialog1.Execute then begin

MediaPlayer1.FileName:=OpenDialog1.FileName;

Label1.Caption:= 'Загружен файл " '+ MediaPlayer1.FileName+'';

MediaPlayer1.Open;

end;

8. Записать код для процедуры обработки события Click (щелчок мыши) на кнопке Button2:

procedure TForm1.Button2Click(Sender: TObject);

begin

Form1.Close;

end;

9. Запустить и при успешной работе сохранить программу.

9. Разместить на форме надпись с текстом гиперссылки. Установить шрифт синего цвета с подчеркиванием. При подводе курсора сделать подсказку "Сайт преподавателя" и курсор в виде ручки.

Практическая работа №24

Создание текстового редактора

Цели работы: Создание текстового редактора, в который можно загрузить файл, отредактировать его и оформить

1. Поместить компоненты RichEdit (вкладка Additional), MainMenu, RadioButton (вкладка Standard) и OpenDialog, ColorDialog (вкладка Dialogs) в форму Form1.

2. Вызвать текстовый редактор Блокнот и создать в нем текстовый файл My_text.txt с содержанием:

Объект

Свойство

Значение

Form1

Caption

Редактирование

RichEdit

Caption

RichEdit

Alignment

TaLeftJustify

Открыть Ctrl+O

Caption

Открыть

-

Caption

Выход

Caption

В&ыход

OpenDialog

Filter

Текстовые файлы (*.txt; *.rtf) |*.txt; *.rtf

RadioButton

Caption

Переключатель

GroupBox1

Caption

-

2.Сохранить файл в папку RichEdit.

3. Начать новый проект и сразу сохранить его в папке RichEdit.

4. Поместить компонент RichEdit в форму и установить для свойства ScrollBars

(линейки прокрутки) значение ssBorth, а для свойства Align (размещение) значение

alLeft (левая часть формы).

5. Записать код для процедуры обработки события Click (щелчок мыши) на подменю OpenFile:

procedure TForm1.OpenFileClick(Sender: TObject);

begin

if (OpenDialog1.Execute) then

RichEdit1.lines.LoadFromFile(OpenDialog1.FileName);

end;

6. Записать код, позволяющий сохранить файл при закрытии формы:

procedure TForm1.CloseEditClick(Sender: TObject);

begin

Form1.Close;

end;

7. Запустить программу. Добавить что-нибудь в появившийся текст. Закрыть программу.

8. Запустить ее еще раз и убедиться, что загружается откорректированный текст.

9. Запустить ее еще раз и убедиться, что сохранятся откорректированный текст.

10. Добавить группу переключателей (RadioButton) для выбора цвета окна и записать соответствующий код.

11. Добавить группу переключателей для выбора размера шрифта.

12. Добавить группу переключателей для выбора вида шрифта.

Список литературы

1. Бондарев В.М., Рублинецкий В.И., Качко Е.Г. Основы программирования. - Харьков: Фолио, 2013. - 368 с.

2. Дантеманн Д., Мишел Д., Тейлор Д. Программирование в среде Delphi / Пер. с англ. - К.: НИПФ "ДиаСофт Лтд.", 2012. -608 с.

3. Дарахвелидзе П.Г., Марков Е.П. Delphi - среда визуального программирования. - СПб.: BHV, 2014. -352 с.

4. Калверт Ч. Программирование в Windows: Освой самостоятельно за 21 день / Пер. с англ. - М.: БИНОМ, 2011. - 496 с.

5. Калверт Ч. Delphi 2. Энциклопедия пользователя / Пер. с англ..- К.: НИПФ "ДиаСофт Лтд.", 2014. - 736 с.

6. Конопка Р. Создание оригинальных компонент в среде Delphi / Пер. с англ. - К.: НИПФ "ДиаСофт Лтд.", 2014. - 512 с

7. Культин Н.Б. Программирование в Turbo Pascal 7.0 и Delphi. - СПб.: BHV, 2013. - 240 с.