Конструкторы и деструкторы.

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

Постараться объединить удобство индексов с эффективностью указателей

 ( Внести в раздел TYPE тип данных "массив фиктивной длинны". Каждое индексное выражение заменить на его "фиктивный" эквивалент).

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

1) Заметим, что проход по обоим векторам осуществляется всего один раз, поэтому от вспомогательных указателей pa и pb можно и отказаться. Вместо них будем использовать уже имеющиеся a и b.

2) Для организации цикла используем указатели. Как это осуществить уже рассказывалось в разделе Указатели.

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

№5: Динамическая память. Создание динамических переменных и их удаление. Использование динамической памяти для временного хранения промежуточной информации.

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

Динамическая память – это оперативная память ПК, предоставляемая программе при ее работе, за вычетом сегмента данных (64 Кбайт), стека (обычно 16 Кбайт) и собственно тела программы. Ее размер составляет не менее 200-300 Кбайт. Динамическая память используется для обработки массивов большой размерности, а так же для временного запоминания при работе с графическими и звуковыми средствами ПК.

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

Динамическая память и ее использование

x= F(x)                   WHILE d>E

x                            [x:=y

y:= F(x)                  [y:=F(x)

d:= ||x-y||;               [d:=||x-y||

Procedure SuccIters (F: FuncN; n: WORD; px: REAL; eps: REAL);

TYPE

       FuncN = Procedure (px, py: RealPtr);

Для решения задачи пользователь должен написать процедуру …

Процедура по заданному Х вычисляет вектор у, но функции y:= F(x) применяем к Х функцию F.

Px – указатель на начало типа Real.

Py – указатель на число, куда стоит разместить вычисленный вектор у.

Размерность задачи (кол-во координат х и у) пользователю неизвестна.

PROCEDURE SuccIters (Func: VectN …);

Процедура вычисляет приближенное значение f типа funcn

TYPE VectN = PROCEDURE (px, py: RealPtr);

px: RealPtr – адрес оперативной памяти для размещения вектора Х.

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

Eps: Real – Критерий для остановки операции приближения. Положительное число. Процедура прекращает свою работу и возвращает результат, когда евклидово расстояние ?(много непонятных слов)? становится < Eps.

Копирование вектора.

Функция вычисления квадрата расстояния

Function Distr (px, py: RealPtr; n: WORD): Real;

Proc CopyVector (py, px: RealPtr, n: WORD);

F1. Пусть Р – типизированный указатель, например, P: RealPtr. Процедура New(p); выделяет из динамической памяти участок такого типа, на который указывает Р.

Самому указателю присваивается в виде значения адрес начала этого участка. После этого P^ является новой созданной переменной на которую указывает указатель Р.

После использования динамическую память нужно освободить. Dispose(P);

Процедура Get_Mem(p, size) выделяет из динамической памяти участок не меньше, чем “size” байт.

SizeOf(x:Real); - адрес, в начало этого участка помещается указатель.

p^ - первый элемент созданного вектора, если p инкрементировать ( inc(p) ), то p^ станет следующим элементом вектора, если декрементировать – предыдущим.

FreeMem(p, size) – освобождает участок динамической памяти.

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

//затем следует много кода, который и по скану можно разобрать

№ 6: «Удобное» программирование с использованием классов математических объектов.

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

//расписать обращение с памятью
//использование конструкторов и деструкторов

Для описания методов в ООП используются традиционные для Pascal процедуры и функции, а также особый вид процедур - конструкторы и деструкторы. Конструкторы предназначены для создания конкретного экземпляра объекта, ведь объект - это тип данных, то есть "шаблон", по которому можно создать сколько угодно рабочих экземпляров данных объектного типа (например, типа TGraphObj). Зарезервированное слово Constructor, используемое в заголовке конструктора вместо Procedure, предписывает компилятору создать особый код пролога, с помощью которого настраивается так называемая таблица виртуальных методов. Если в объекте нет виртуальных методов, в нем может не быть ни одного конструктора, наоборот, если хотя бы один метод описан как виртуальный (с последующим словом Virtual, см. метод Draw), в состав объекта должен входить хотя бы один конструктор, обращение к конструктору должно предшествовать обращению к любому виртуальному методу.

1. Конструктор и деструктор - это методы, которые используются для создания и разрушения объекта соответственно.
2. Объект - это экземпляр класса.
3. Объявив класс, мы не получим объект - его надо создать.

Конструкторы и деструкторы.

Методы, которые предназначены для создания и удаления объектов называются конструкторами и деструкторами соответственно. Описание данных методов отличается от обычных тем, что в их заголовках стоят ключевые слова constructor и destructor. В качестве имен конструкторов и деструкторов в базовом классе TObject и многих других классах используются имена Create и Destroy.

Прежде чем обращаться к элементам объекта, его нужно создать с помощью конструктора. Например: ObjectA:=TOwnClass.Create;

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

Классы объектов определяются в секции type глобального блока. Описание класса начинается с ключевого слова class и заканчивается ключевым словом end.

Чтобы от описания класса перейти к объекту, следует выполнить соответствующее объявление в разделе var:Var math:TMatematica;

Переменная math – это ссылка на экземпляр (объект в памяти), которого физически еще не существует. Чтобы сконструировать объект (выделить память для экземпляра) класса TMatematica и связать с ним переменную math, нужно в тексте программы поместить следующий оператор: math:= TMatematica.Create;

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

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

Кроме того, как и при работе с записями, допустимо использование оператора with, например:

with math do

x1;

Если объект становится ненужным, он должен быть удален вызовом специального метода Destroy (освобождение памяти, занимаемой объектом), например: math.Destroy;

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

Вызов деструктора для несуществующих объектов недопустим и при выполнении программы приведет к ошибке. Чтобы избавить от лишних ошибок, в объекты ввели предопределенный метод Free, который следует вызывать вместо деструктора. Метод Free сам вызывает деструктор Destroy, но только в том случае, если значение объектной переменной не равно nil: math.Free;

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

math.Free;

math:= nil;

С помощью стандартной процедуры FreeAndNil это можно сделать проще и элегантнее:

FreeAndNil(math);

№7: Система обработки ошибок в модуле.

Учет и обработка ошибок

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

       Кодификатор всегда начинается со строки «0». 0 – нет ошибки.

Ошибка:

- несуществующий вектор (операнда)

- несоответствие размерности

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

PROCEDURE OnError (place: string);

VAR ec: WORD;

Begin

       IF ec <> 0 THEN

                   BEGIN

                   WRITELN;

                   WRITELN(‘Ошибка номер’, ec, ‘в месте’, place);

                   HALT;

                   END;

End;

OnError(‘SuccIters: NewI’) ; { Copy , F(x), C

№8. Среда Delphi, структура программы, модуля. Работа с проектом. Примеры.

Интегрированная Среда Разработки (Integrated Development Environment — IDE) — это среда, в которой есть все необходимое для проектирования, запуска и тестирования приложений и где все нацелено на облегчение процесса создания программ. ИСР интегрирует в себе редактор кодов, отладчик, инструментальные панели, редактор изображений, инструментарий баз данных — все, с чем приходится работать.

Запускаем Delphi с помощью меню Windows Пуск | Программы. Когда мы щелкнем на пиктограмме Delphi, перед нами откроется основное окно Интегрированной Среды Разработки. Для версий Delphi, отличных от Delphi 5, окно выглядит несколько иначе, но в основных чертах окна ИСР всех версий Delphi одинаковы.

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

Ниже полосы главного меню расположены две инструментальные панели. Левая панель содержит два ряда быстрых кнопок, дублирующих некоторые наиболее часто используемые команды меню. Правая панель содержит палитру компонентов библиотеки визуальных компонентов (Visual Component Library — VCL). В ней содержатся и визуальные (видимые пользователю), и невизуальные компоненты (они явным образом не видны пользователю). Палитра компонентов содержит ряд страниц, закладки которых видны в ее верхней части.

В основном поле окна мы видеим слева окно Инспектора Объектов (Object Inspector), с помощью которого мы в дальнейшем будем задавать свойства компонентов и обработчики событий. Правее мы можем видеть окно пустой формы, готовой для переноса на нее компонентов. Под ним расположено окно Редактора Кодов. Обычно оно при первом взгляде на экран невидимо, так как его размер равен размеру формы и окно Редактора Кодов полностью перекрывается окном формы.

Создание нового проекта приложения начинается с команды File | New Application. По этой команде открывается новый проект приложения с пустой формой. Сохранить на диске готовый проект или его заготовку можно командой File | Save Project As или File | Save All. Удобно также для сохранения использовать быстрые кнопки — третью или четвертую слева в верхнем ряду. Открыть ранее сохраненный проект можно командой File | Open или File | Open Project (вторая слева быстрая кнопка в верхнем ряду). Но если вы недавно работали с этим проектом, то удобнее воспользоваться командой File | Reopen или кнопочкой справа от быстрой кнопки Open. Эта команда дает возможность быстро выбрать проект из числа тех, с которыми вы работали последнее время.

Для компиляции и запуска на выполнение приложения надо выполнить команду Run | Run (быстрая кнопка с зеленой стрелкой, пятая в нижнем ряду).

Палитра компонентов — витрина библиотеки визуальных компонентов (Visual Component Library — VCL). Чтобы осуществить операцию переноса компонентов из палитры на форму, надо открыть соответствующую страницу библиотеки и указать курсором мыши необходимый компонент. Затем надо сделать щелчок мышью в нужном месте формы и компонент разместится там. В дальнейшем мы можем отбуксировать его в любое другое место.

Форма, на которой размещаются компоненты, является основой почти всех приложений Delphi. Ее можно понимать как типичное окно Windows. Форма является контейнером (родителем — Parent)размещенных на ней компонентов.

Одной из наиболее важных частей среды Delphi является окно Редактора Кода. В действительности, если вы откроете в первый раз это окно в Delphi 5, оно может выглядеть несколько иначе и включать в себя слева еще одно встроенное окно — окно Исследователя Кода Code Explorer. В большинстве случаев вы просто можете закрыть его, щелкнув на кнопке с крестиком в его правом верхнем углу. Чтобы оно вообще больше не появлялось, выполните команду Tools | Environment Options и в открывшемся диалоговом окне на странице Explorer выключите опцию Automatically show Explorer (показывать автоматически окно Code Explorer).

Редактор Кода является полноценным программным редактором. Его можно настраивать на различный стиль работы, который нам более привычен. В редакторе применяется выделением цветом синтаксических элементов. Жирным шрифтом выделяются ключевые слова языка Object Pascal. Синим курсивом выделяются комментарии.

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

В окно Редактора Кода, как и в другие окна Delphi, встроена контекстная справка. Чтобы получить справку по какому-то слову кода (ключевому слову, написанному имени функции и т.п.) достаточно установить курсор на это слово и нажать клавишу F1. Нам будет показана соответствующая тема справки.

Следующим важнейшим элементом среды разработки является Инспектор Объектов (Object Inspector). Он обеспечивает простой и удобный интерфейс для изменения свойств объектов Delphi и управления событиями, на которые реагирует объект.

Страница свойств (Properties) Инспектора Объектов (см. рис. 1.3 а), показывает свойства того объекта, который в данный момент выделен нами. Щелкнем на окне пустой формы и на странице свойств Инспектора Объектов мы сможем увидеть свойства формы. Мы можем изменять эти свойства. Например, изменить свойство Caption (надпись) нашей формы, написав в нем «Моя форма», и вы увидите, что эта надпись появится в полосе заголовка вашей формы.

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

№9. Компиляция программы Delphi. Работа с несколькими объектами на форме. Процедуры обработки событий. Свойства формы. Примеры.

В процессе компиляции проекта создается готовый к использованию файл, которым может быть приложение (ЕХЕ) или динамически загружаемая библиотека (DLL). Далее будем рассматривать только файл-приложение. Имя приложения, получаемого в результате компиляции, совпадает с име­нем файла проекта, а само приложение является автономным и не требует для своей работы дополнительных файлов Delphi.

Запуск процесса компиляции выполняется по команде Project | Compile <Project1> (Проект | Компилировать <проект>) или нажатием комбинации клавиш <Ctrl>+<F9>. В этой команде содержится имя проекта, разработка которого выполняется в настоящий момент, первоначально это Projectl. При сохранении проекта под другим именем соответственно должно изме­ниться имя проекта в команде меню.

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

При компиляции про­екта выполняются следующие действия:

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

2. если в модуль были внесены изменения, то перекомпилируется не только этот модуль, но и использующие его с помощью директивы uses МОДУЛИ;

3. перекомпиляция модуля происходит также при изменениях объектного файла или подключаемого файла (INC), используемых данным модулем;

4. после компиляции всех модулей проекта компилируется файл проекта и создается исполняемый файл приложения с именем файла проекта.

Кроме компиляции может быть выполнена сборка проекта. При сборке компилируются все файлы, входящие в проект, независимо от того, были в них внесены изменения или нет. Для сборки проекта используется команда меню Project | Build <Project1> (Проект | Собрать <проект1>).

Запустить проект на выполнение можно из среды Delphi и из среды Windows.

Выполнение проекта из среды Delphi осуществляется командой Run | Run (Выполнение | Выполнить) или нажатием клавиши<F9>. При этом созданное приложение начинает свою работу. Если в файлы проекта вносились изменения, то предварительно выполняется компиляция проекта. Запущенное приложение работает так же, как и запущенное вне среды Delphi, однако имеются некоторые особенности:

· нельзя запустить вторую копию приложения;

· продолжить разработку проекта можно только после завершения работы приложения;

при зацикливании (зависании) приложения его завершение необходимо выполнять средствами Delphiс помощью команды Run | Program Reset (Выполнение | Остановить программу) или комбинации клавиш<Ctrl>+<F2>.

Из среды Windows созданное приложение можно запустить как и любое другое приложение, например, с помощью Проводника.

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

Событие (Event) – это то, что происходит во время работы программы. В Delphi каждому событию присвоено имя. Например, щелчок кнопкой мыши – это событие OnClick, двойной щелчок мышью событие OnDblClick.

Реакцией на событие должно быть какое-либо действие. В Delphi реакция на событие реализуется как процедура обработки события. Таким образом, для того чтобы программа выполняла некоторую работу в ответ на действия пользователя, программист должен написать процедуру обработки соответствующего события. Следует обратить внимание на то, что значительную часть обработки событий берет на себя компонент. Поэтому программист должен разрабатывать процедуру обработки события только в том случае, если реакция на событие отличается от стандартной или не определена. Например, если по условию задачи ограничений на символы, вводимые в поле Edit, нет, то процедуру обработки события OnKeyPress писать не надо, т. к. во время работы программы будет использована стандартная (скрытая от программиста) процедура обработки этого события.

Action - определяет объект TAction. Это объект служит для быстрой привязки действий к компонентам, в особенности - к пунктам меню и панелям инструментов. Но может быть привязан и к форме. Для управления TAction служат редакторы TActionList со страницы Standard и TActionManager со страницы Additional.

ActiveControl - определяет элемент, который имеет в данный момент фокус ввода. Если выбрать какой-либо объект во время разработки (design-time), то при запуске приложения этот объект и будет иметь фокус ввода. Также свойство может быть полезно и во время выполнения (run-time) - можно узнать, какой объект "держит" фокус в данный момент, а также можно переместить фокус на любой из объектов. Пример: разместим на форме 2 кнопки - Button1 и Button2, а также TTimer (страница System). Выбрав элемент Timer1, дважды щёлкнем в Инспекторе объектов напротив надписи OnTimer на вкладке Events, т.е. создадим обработчик события и напишем следующее: ActiveControl:=Button2; Теперь, запустив программу, каждую секунду фокус будет перемещаться на Button2.

Align - определяет выравнивание формы на экране. Свойство принимает одно из следующих значений:

• alBottom - по нижнему краю;
• alClient - вся пользовательская (клиентская) область;
• alCustom - выравнивание определяется вызовом методом объекта-родителя;
• alLeft - по левому краю;
• alNone - без выравнивания;
• alRight - по правому краю;
• alTop - по верхнему краю.

AlphaBlend - включает/выключает прозрачность формы.

AlphaBlendValue - задаёт степень непрозрачности формы: 0 - форма полностью невидима, 255 - полностью видима. Прозрачность активируется только при установке свойства AlphaBlend в True.

Anchors - определяет направления, по которым компоненты "привязываются" к форме. Пример: если установить у формы значения akLeft и akRight этого свойства в True, и точно также сделать у кнопки, то при изменении ширины формы размер кнопки (ширина) также будет изменяться.

AutoScroll - включает автоматическое появление полос прокрутки (Scroll bars) на форме, когда размеров формы недостаточно для отображения всех элементов.

AutoSize - включает автоматическое изменение размеров формы согласно позициям размещённых на ней элементов.

BiDiMode - определяет двунаправленное отображение элемента. В некоторых языках письмо осуществляется не слево-направо, а наоборот. Это свойство создано как раз для этой цели.

BorderIcons - определяет множество кнопок, которые отображаются в заголовке окна:

• biSystemMenu - единственный элемент, который не является кнопкой - отвечает за системное меню окна, которое вызывается комбинацией клавиш [Alt]+[Пробел].
• biMinimize - кнопка сворачивания (минимизации) окна;
• biMaximize - кнопка разворачивания окна;
• biHelp - кнопка справки.

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

BorderStyle - определяет поведение границ окна и общий тип окна:

• bsDialog - диалоговое окно (из кнопок - только "Закрыть", иконки в заголовке окна нет);
• bsNone - "чистый лист" (отсутствие у окна границ и заголовка) - применяется обычно для создания заставок во время запуска программы;
• bsSingle - обычное окно, но с запретом изменения размеров;
• bsSizeable - обычное окно (по умолчанию) - размеры формы можно изменять;
• bsSizeToolWin - упрощённое окно с уменьшенным заголовком;
• bsToolWindow - упрощённое окно с уменьшенным заголовком без возможности изменения размеров.

BorderWidth - ширина границы окна в пикселах. Граница является невидимой и расположена в пользовательской части формы.

Caption - текст заголовка формы.

ClientHeight, ClientWidth - размер клиентской (пользовательской) части формы, т.е. той, на которой располагаются компоненты.

Color - цвет формы.

Constraints - определяет минимальные и максимальные размеры высоты и ширины формы в пикселах. 0 - любое значение, т.е. без ограничений.

Ctl3D - свойство определяет 3D-вид формы. При выключенном - "плоское" изображение.

Cursor - курсор мыши в тот момент, когда он находится над формой.

DefaultMonitor - определяет, на каком мониторе появится форма. Имеет смысл применять это свойство только при наличии более, чем одного монитора (например, если несколько экранов).

DockSite, DragKing и DragMode - определяют поведение формы при осуществлении операций Drag&Drop.

Enabled - отвечает за общую активность формы. Если установлено в False, форма недоступна.

Font - шрифт, используемый на форме.

FormStyle - стиль формы или её поведение в MDI-приложении (многооконное приложение, где дополнительные формы располагаются "внутри" основной формы). Значения:

• fsNormal - обычная форма (значение по умолчанию);
• fsMDIChild - дочерняя (подчинённая) форма MDI-приложения;
• fsMDIForm - главная форма MDI-приложения;
• fsStayOnTop - форма находится поверх всех окон на экране.

Height - высота формы в пикселах. В отличие от ClientWidth является высотой с учётом заголовка и границ формы.

HelpContext, HelpFile, HelpKeyword, HelpType - свойства для связи формы с файлом справки в форма

Hint - текст всплывающей подсказки.

HorzScrollBar - свойство определяет внешний вид и поведение горизонтальной полосы прокрутки окна.

Icon - значок (иконка) формы. Отображается в заголовке слева от заголовка. Задаётся файлом в формате *.ico.

KeyPreview - если свойство установлено в True, то при нажатии клавиш сначала будут вызываться обработчики формы, а только затем обработчики того компонента, который в данный момент имеет фокус ввода. События, связанные с нажатием клавиш - OnKeyDown(), OnKeyPress(), OnKeyUp().

Left - позиция формы на экране (левого верхнего угла) в пикселах.

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

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

ObjectMenuItem - используется при работе с OLE-объектами и позволяет связать пункт меню и OLE-объект: когда объект выделен, пункт меню активен и наоборот.

OldCreateOrder - определяет, когда происходят события OnCreate() и OnDestroy() формы. Если установлено в False, то OnCreate() произойдёт после вызова всех конструкторов, а OnDestroy() - после вызова всех деструкторов. Начальное значение - False, изменять не рекомендуется.

ParentBiDiMode - изменение свойства BiDiMode согласно значению объекта-предка формы.

ParentFont - изменение шрифта (Font) согласно значению объекта-предка.

PixelsPerInch - пропорции шрифта в системе (точек на дюйм).

PopupMenu - позволяет указать контекстное меню (объект TPopupMenu) для формы. Это меню вызывается нажатием правой кнопки мыши.

Position - определяет начальную позицию формы на экране, т.е. в момент её появления. Основные значения:

• poDesigned - появление в том месте, в каком форма расположена в design-time;
• poDesktopCenter - по центру рабочего стола (рекомендуемое значение);
• poScreenCenter - по центру экрана;
• poMainFormCenter - по центру главной формы приложения (для главной формы не имеет смысла).

PrintScale - определяет размеры формы при выводе её изображения на печать.

Scaled - включает масштабирование формы в соответствии с заданным значением свойства PixelsPerInch.

ScreenSnap - если установлено в True, то форма будет автоматически "прилипать" к краям экрана в момент перемещения.

SnapBuffer - определяет расстояние (в пикселах), на котором форма будет "прилипать" к краю экрана.

ShowHint - включает/выключает показ всплывающей подсказки (Hint).

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

Top - позиция формы (левого верхнего угла) на экране в пикселах.

TransparentColor - включает/выключает прозрачность определённого цвета формы.

TransparentColorValue - задаёт цвет, который будет прозрачным.

UseDockManager - используется при реализации Drag&Drop технологии, предоставляя дополнительные возможности этого метода взаимодействия.

VertScrollBar - определяет внешний вид и поведение вертикальной полосы прокрутки окна.

Visible - определяет видимость формы на экране.

Width - ширина окна в пикселах, включая границы.

WindowMenu - свойство-аналог свойства Menu, но используемое при создании MDI-форм.

WindowState - одно из состояний окна:

• wsNormal - обычное состояние (занимает часть экрана);
• wsMinimized - окно свёрнуто;
• wsMaximized - окно развёрнуто на весь экран.

№10. Классы, инкапсуляция и наследование, полиморфизм. Примеры.

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

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

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

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

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

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

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

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

Замещать можно и переменные. В подобном разноликом поведении и заключается третий принцип объектно-ориентированного программирования - Полиморфизм.

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

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

В Delphi все классы наследуются от одного предка - базового класса TObject. Этот класс не только дает всем своим потомкам ряд нужных всем им методов, например, методы создания и уничтожения экземпляров класса, но и обеспечивает базовую совместимость любых объектов. Все компоненты в Delphi - объекты. Можно создавать новые компоненты в

Delphi.

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

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

Программа Delphi не является сплошным последовательным выполнением кода, как в Turbo Pascal. Здесь программа реализует некоторый код только как реакцию на события -какие-то действия пользователя (нажатие кнопок, движение мыши, закрытие окон и т.п.). Когда код, описанный в обработчике, заканчивается, программа не завершается. Для завершения требуется, чтобы пользователь обычным в Windows способом закрыл главное окно приложения либо, к примеру, нажал на сделанную кнопку, в обработчике нажатия которой предусмотрен вызов процедуры Close.

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

EDIT- однострочный редактор для ввода, вывода и модификации данных

MEMO- многострочный текстовый редактор для вывода, ввода и изменения

LABEL- метка, для размещения заголовков, и других поясняющих надписей

STATICTEXT- метка, для размещения надписей в рельефной рамке

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

Каждый компонент получает свое имя (имя компонента и номер, например EDIT1 – первый однострочный редактор, размещенный на форме, EDIT2 - второй однострочный редактор, размещенный на форме и т.д.)

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

Имя компонентаСвойство для ввода/вывода

EDITTEXT(в программе записывается EDIT1.TEXT)

MEMOTEXT(в программе записывается MEMO 1.TEXT)

LABELCAPTION (только вывод)(LABEL1.CAPTION)

STATICTEXTCAPTION (только вывод)(STATICTEXT1.CAPTION)

STRINGGRIDмассив CELLS [номер столбца, номер строки] в программе записывается STRINGGRID1.CELLS[ j,i ]

Для компонента MEMO часто используется свойство «строка» LINES в сочетании с методом «добавить» ADD. ( в программе записывается MEMO1.LINES.ADD ( ) ).

Указанные свойства этих компонентов имеют строковый тип, т.е. тип STRING, поэтому при вводе числовых данных необходимо выполнить соответствующие преобразования данных

при вводе надо перевести данные из строкового типа в числовой, а именно в целочисленный тип или вещественный тип с помощью функций STRTOINT ( ) или STRTOFLOAT ( );

при выводе данные надо перевести из целочисленного или вещественного типа в строковый с помощью функций INTTOSTR ( ) или FLOATTOSTR ( )

Для выполнения этих операций используется оператор присваивания « := »языка Паскаль.

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

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

Для многострочного редактора существует несколько способов вывода данных:

способ 1Memo1.Text := ‘вывод с потерей всего выведенного ранее’;

способ 2Memo1.Text := Memo1.Text + ‘вывод с сохранением выведенного ранее’;

способ 3Memo1.Lines.Add (‘ добавить строку и вывести все, что в апострофах‘) ;

Способы 1 и 2 не вводят новой строки.

Примеры

Вывод в поле метки 1 слова МоскваLabel1.Caption := ‘ Москва ‘;

Вывод в поле метки 2 числа 25Label2.Caption := ‘ 25 ‘ ;

Вывод в поле метки 1 числа 10,23StaticText1 := ' 10.23 ‘ ;

Ввод в переменную А числа 5 из компонента Edit1А:= strtoint(Edit1.Text)

Вывод в поле Memo1 значения переменной А Memo1.Text :=inttostr (A) ;

Если выполнить вывод в поле Memo1 из компонента Edit1, то записывается команда Memo1.Text := Edit1.Text

5

- компонент Edit1

Ввод в переменную массива В[i,j] целочисленного значения из ячейки StringGrid1

B [ i,j ] :=StrToInt ( StringGrid1.Cells[ j,i ] );

Организация вывода элементов одномерного массива

Элементы одномерного массива можно вывести в разные компоненты.

1. Вывод в компонент Edit

For I := 1 to M do

Edit1.Text:=Edit1.Text + ' '+ IntToStr(A[I])

2. Вывод в компонент Label1

For I := 1 to M do

Label1.Text:=Label1.Text + ' '+ IntToStr(A[I])

3. Вывод в компонент StaticText

For I := 1 to M do

StaticText1.Caption := StaticText1.Caption + IntToStr (A[I]) + ' ';

4. Вывод в компонент Memo

4.1. В строку:

For I := 1 to M do

Memo1.Text:=Memo1.Text + ' '+ IntToStr (A[I]) { использование свойства

Text компонента Memo}

4.2. В столбик

For I := 1 to M do

Memo1.Lines.Add ( IntToStr (A[I]) ) {использование метода Add –

добавление новой строки в список}

5. Вывод одномерного массива Sum в столбец № 1 ком-та stringgrid1

for i := 1 to m do

stringgrid1.Cells[ 1, i ]:= floattostr(sum [ i ] );

В строку № 1 компонента Stringgrid :

for j := 1 to n do

stringgrid1.Cells[ j, 1 ]:= floattostr(sum [ j ] );

Организация вывода элементов двумерного массива

1. Вывод матрицы В в stringgrid2

for i := 1 to m do

for j:=1 to n do stringgrid2.cells[ j,i ]:=floattostr (b [ i,j ]);

2. Вывод матрицы В в компонент Memo с расчетом позиций чисел и в файл 'd:\rez.txt'

var ff :textfile ;

d,p,z,i,j:integer; // позиции, счетчик пробелов, длина числа

ss,aa :string; // промежуточные строки ss –строка матрицы ;

// аа-строка для числа

begin

assignfile (ff,'d:\rez.txt'); // связь с файлом на диске

rewrite (ff); // открыть файл для записи

ss:='';

d:=8; // 8 позиций на число

memo2.Lines.Add('матрица В') ; // вывод в memo2

writeln(ff,'матрица В') ; // вывод в файл

for I:=1 to m do begin

For j:=1 to n do

Begin aa:= floattostr (b[i,j]); //расчет длины числа и добавление пробелов

// до 8 символов (на 1 число)

z:= d - length (aa);

if b[i,j] <0 then z:=z+1;

for p:=1 to z do SS:=ss+' '; // 1 пробел между апострофами

ss := ss + floattostr (b[i,j]) +' '; // 2 пробела между апострофами

end;

memo2.Lines.Add(ss) ;

writeln(ff,ss) ;

ss:=''; // без пробелов между апострофами

d:=8; end;

closefile(ff);// закрыть файл

end;

end.

Вид файла D : \ rez.txt с результатами :

матрица В

10,7 2,2 3,3 4,1

10,5 6,3 1,1 -2,1

1,1 5 0,3 -1,1

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

procedure TForm1.FormCreate(Sender: TObject);

begin

end;

В разделе типов, в объявлении объекта Form1 появилось имя процедуры:

Procedure FormCreate(Sender: TObject); - поднимитесь вверх по тексту и проверьте так ли это.

Вернемся к нашей процедуре создания окна и сами напишем реакцию на создание формы. Изменим свойство - цвет окна. Между словами begin и end напишем следующую строку:

Form1.Color:= clNavy;

Запустим программу на исполнение - цвет окна изменился на тёмно- синий.

12. Компоненты выбора, выполнения действия программы Delphi. Организация работы с различными типами данных.

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

Delphi для работы с переключателями предлагает следующие компоненты:

• переключатель с независимой фиксацией (CheckBox), флажок этой компоненты можно переключать щелчком мыши;
• переключатели с зависимой фиксацией – RadioButton (кнопки выбора), RadioGroup (группа переключателей RadioButton).

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

Компонент Delphi CheckBox это флажок - независимый переключатель. Флажок Delphi CheckBoxиспользуется в программе для визуализации состояний включено-выключено. Каждый щелчок мышкой по компоненту Delphi CheckBox меняет его состояние на противоположное. Смена состояния переключателя также доступна и в программе.

Delphi CheckBox представляет собой сочетание небольшого окошка, которое и визуализирует наличием или отсутствием "галочки" состояние компонента, и компонента Label - заголовка, поясняющего назначение переключателя.

Основное свойство компонента CheckBox - Checked типа Boolean. То есть, на приведённом рисунке
CheckBox1.Checked = False;
CheckBox2.Checked = True;

Помимо свойства Checked, позволяющего управлять состоянием компонента, у Delphi CheckBox есть свойство State (состояние), которое может иметь уже три значения. Первые два значения cbChecked ("отмечено") и cbUnChecked ("не отмечено"), а третье - cbGrayed ("не определено" или "не знаю") становится доступным для выбора если установить в True свойство AllowGrayed компонента. Свойства Checked и State связаны между собой:

если свойство State равно cbChecked, свойство Checked = True;

если свойство State равно cbUnchecked или cbGrayed, свойство Checked = False.

При щелчке мышкой эти три состояния сменяют друг друга в следующей последовательности:

cbGrayed - не определено (или "не знаю");

cbChecked - отмечено;

cbUnChecked - не отмечено;

Компонент Delphi RadioGroup расположен на странице Standard Палитры Компонентов. Он представляет собой контейнер с группой компонентов RadioButton (переключателей). Такой компонент упрощает организацию работы переключателей, по сравнению другими групповыми контейнерами требующими добавлять переключатели вручную.

Компонент RadioGroup может содержать и другие компоненты, такие как редактор Edit или флажок CheckBox. Но автоматическое форматирование и распределение элементов на них не будет распространяться. В результате внешний вид приложения может пострадать тем, что элементы если и не будут перекрывать друг друга, то будут неравномерно располагаться относительно переключателей.

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

Основное свойство компонента RadioGroup это Items. В нем находятся строки, которые являются заголовками переключателей. Двойным щелчком на многоточии рядом с Items в Инспекторе Объектов мы попадаем в редактор списков строк, где каждая отдельная строка будет заголовком переключателя (радиокнопки). Отсчет строк идет с нуля. Элемент Items[2] будет третьим. Для работы с элементами используются методы: Add, Delete, Clear.

Свойство Columns зададим равным двум.

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

Пункты с 1 по 6 введем в редакторе строк. Щелкнув в Инспекторе Объектов на многоточие напротив Items.

Для кнопки Добавить введем такой обработчик:

RadioGroup1.Items.Add('семь');

RadioGroup1.Items.Add('восемь');

Для кнопки Очистить:

RadioGroup1.Items.Clear;

Для кнопки Удалить:

RadioGroup1.Items.Delete(RadioGroup1.ItemIndex);

Для кнопки Показать:

Label1.Caption := IntToStr(RadioGroup1.ItemIndex);

 Запустим нашу программу. Нажав кнопку Добавить мы получим два новых элемента в нашей группе. Нажимая так несколько раз элементов может стать достаточно много. И компонент CheckBox будет мешать обзору, так как он не будет автоматически перемещаться как родные элементы компонента RadioGroup.

Кнопка Удалить удаляет текущий переключатель (радиокнопку).

Кнопка Очистить удаляет все родные переключатели посторонние компоненты не трогает. Компонент CheckBox останется на своем месте как и стоял.

Кнопка Показать с помощью компонента Label1 показывает нам номер номер выбранной радиокнопки. Если выбор не сделан то будет -1. Нумерация переключателей (радиокнопок) начинается с 0.