Delphi структура модуля - IT Справочник
Llscompany.ru

IT Справочник
2 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Delphi структура модуля

Delphi структура модуля

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

  1. Запустите Delphi, если вы еще это не сделали, с помощью меню Windows Пуск | Программы . Если Delphi уже работает и вы уже делали какие-то эксперименты с формой, то откройте новое приложение. Для этого вам надо выполнить команду File | New Application . Ответьте « No » на вопрос Delphi, хотите ли вы сохранить изменения в вашем проекте.
  2. Перенесите на пустую форму, которая открылась вам, кнопку Button со страницы Standard палитры компонентов. Для этого выделите пиктограмму кнопки (она шестая слева) и затем щелкните курсором мыши в нужном вам месте формы. На форме появится кнопка, которой Delphi присвоит имя по умолчанию — Button1.
  3. Аналогичным образом перенесите на форму с той же страницы Standard палитры компонентов метку Label (она на странице третья слева). В этой метке в процессе выполнения приложения будет появляться текст при нажатии пользователем кнопки. Delphi присвоит ей имя Label1.
  4. Разместите компоненты на форме примерно так, как показано на рис. 1.4 а.
  5. Выделите на форме компонент Button1 — кнопку. Перейдите в Инспектор Объектов и измените ее свойство Caption (надпись), которое по умолчанию равно Button1 (имя, которое по умолчанию присвоила этому компоненту Delphi) на « Пуск ».
  6. Сотрите текст в свойстве Caption метки Label1, чтобы он не высвечивался, пока пользователь не нажмет кнопку приложения. Теперь вам осталось только написать оператор, который заносил бы в свойство Caption метки Label1 нужный вам текст в нужный момент. Этот момент определяется щелчком пользователя на кнопке. При щелчке в кнопке генерируется событие OnClick. Следовательно, обработчик этого события вы и должны написать.
  7. Выделите кнопку Button1 на форме, перейдите в Инспектор Объектов, откройте в нем страницу событий ( Events ), найдите событие кнопки OnClick (оно первое сверху) и сделайте двойной щелчок в окне справа от имени этого события. Это стандартный способ задания обработчиков любых событий. Вы окажетесь в окне Редактора Кода и увидите там текст: Заголовок этой процедуры складывается из имени класса вашей формы (TForm1), имени компонента (Button1) и имени события без префикса On (Click).
  8. Напишите в обработчике оператор задания надписи метки Label1. Этот оператор может иметь вид: Оператор, который вы написали, присваивает метке строку текста «Это мое приложение Delphi!».

Если вы работаете с версией старше Delphi 3, написали первый идентификатор оператора — Label1, поставили точку и ненадолго задумались, то вам всплывет подсказка, содержащая список всех свойств и методов метки. Это начал работать Знаток Кода — Code Insight, который стремится подсказать вам свойства и методы компонентов, аргументы функций и их типы, конструкции операторов. Вы можете выбрать из списка нужное ключевое слово, нажать клавишу Enter и выбранное слово (свойство, метод) окажется вписанным в текст.

Этот инструмент очень удобен во многих случаях, когда вы не очень точно помните последовательность перечисления параметров какой-нибудь функции, или когда не уверены в имени какого-то свойства. Но иногда, когда вы хорошо освоитесь с Delphi, эти подсказки, может быть, начнут вас раздражать. Тогда вы можете отключить Знатока Кода, выполнив команду Tools | Editor Options и на странице Code Insight выключив опцию Code Completion . В Delphi 4 аналогичные действия можно сделать командой Tools | Environment Options .

Итак, ваше приложение готово. Можете откомпилировать и выполнить его (команда Run | Run ). После недолгой компиляции перед вами появится окно вашего приложения. Нажав в нем кнопку Пуск , вы увидите указанную вами строку текста (рис. 1.4 б). Можете попробовать различные манипуляции с окном: перемещение его, изменение размеров его рамки курсором мыши, свертывание и развертывание. В заключение закройте приложение, щелкнув на кнопке в его правом верхнем углу.

Теперь посмотрите код программы, который создала с вашей помощью Delphi. Этот код содержится в двух файлах — головном файле программы с расширением .dpr и в файле модуля с расширением .pas. Головной файл .dpr — один на весь проект, а файлов модулей столько, сколько форм вы ввели в свой проект. Добавление в проект новой формы вы можете осуществить командой File | New Form , а удалить форму из проекта можно командой Project | Remove from Project .

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

Ниже приведен текст модуля описанного выше простого примера, который вы можете увидеть в окне Редактора Кода. Подробные комментарии в этом тексте поясняют, куда и что в этот код вы можете добавлять.

Модуль начинается с ключевого слова unit, после которого пишется имя модуля. Оно совпадает с именем файла, в которым вы сохранили свой модуль. По умолчанию для первого модуля имя равно Unit1, для второго Unit2 — и т.д.

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

В разделе interface после предложения uses, содержащего список подключаемых библиотечных модулей, вы можете видеть объявление класса вашей формы, подготовленное Delphi. Имя класса вашей формы — TForm1. В класс включены те объекты которые вы разместили на форме — метка Label1 и кнопка Button1. Кроме того в класс включено объявление того обработчика щелчка на кнопке, который вы создали — процедуры Button1Click.

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

После завершения объявления класса формы вы можете видеть строки

Это объявляется переменная Form1 класса TForm1, т.е. объявляется ваша форма как объекта класса TForm1.

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

В раздел implementation вы можете сами включать помимо обработчиков событий любые объявления глобальных переменных, констант, типов, и описания функций и процедур. Если вы хотите из данного модуля получить доступ к другому разработанному вами модулю (другой форме), то в раздел implementation вам надо включить оператор uses, в котором указать файл модуля, доступ к которому вы хотите получить. Например, предложение обеспечит вам доступ ко всем элементам, объявленным в интерфейсе модулей Unit2 и Unit3.

Delphi структура модуля

// повторения списка параметров

Хотя допускается краткое объявление заголовка подпрограммы ( как в предшествующем примере—функции MulC), тем не менее использовать такую форму в серьезной программе не рекомендуется: перечень параметров непосредственно в заголовке подпрограммы облегчает чтения кода и понимания деталей реализации алгоритма.

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

Function AddC(x,z: Complex): Complex; begin

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

12.5. ИНИЦИИРУЮЩАЯ И ЗАВЕРШАЮЩАЯ ЧАСТИ

Инициирующая и завершающая части чаще всего отсутствуют

Вместе с начинающим их словами initialization и finalization.

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

Читать еще:  Основные единицы си таблица

12.6. ДОСТУП К ОБЪЯВЛЕННЫМ В МОДУЛЕ ОБЪЕКТАМ

Пусть, например, мы создаем модуль, реализующий арифметику комплексных чисел (такая арифметика ни в стандартном Паскале, ни в Object Pascal не предусмотрена, но в Delphi 6 введен пользовательский вариант, который реализует действия над комплексными

Числами — см. п. 10.5 и модуль SourceRtlCommonVarCmplx.pas Каталога размещения Delphi). Арифметика комплексных чисел реализуется четырьмя функциями:

re,im: real end; Function AddC (x,y: Complex): Complex;

Function SubC (x,y: Complex): Complex;

Function MuiC (x,y: Complex): Complex;

Function DivC (x,y: Complex): Complex;

с : Complex = (re : 0.1; im : -1);

Function AddC (x,y: Complex): Complex;

// Сложение комплексных чисел

Result.re := x.re + y.re;

Result.im := x.im + y.im

Function SubC (x,y: Complex): Complex;

// Вычитание комплексных чисел

Result.re := x.re — y.re;

Result.im := x.im — y.im

Function MulC (x,y: Complex): Complex;

// Умножение комплексных чисел

Result.re := x.re * y.re — x.im * y.im;

Result.im := x.re * y.im + x.im * y.re

Function DivC (x,y: Complex): Complex;

// Деление комплексных чисел

z := sqr(y.re) + sqr(y.im);

// Защищаем программу от краха в случае, когда z=0:

try- Result, re := (x.re * у.re + x.im * y.im) / z;

Result.im := (x.re * y.im — x.im * y.re) / z;

Чтобы создать такой модуль, следует вызвать опцию File | New I unit[В Delphi 1 для этого используется опция File | New | Unit, в версиях 2. 5 — опция File |

New и выбор пиктограммы на закладке New окна Репозитория. ]. Текст модуля следует сохранить в файле cmplx.pas: имя файла должно совпадать с именем модуля — только в этом случае Delphi сможет автоматически найти модуль и следить за его обновлением.

После создания модуля его имя нужно упомянуть в предложении uses того модуля, в котором будут использоваться вновь созданные подпрограммы, типы, константы (в нашем модуле — тип complex, подпрограммы Addc, subc. Mule, Dive и константа с). Пусть, например, при каждом щелчке по кнопке bbRun учебной программы создается пара случайных комплексных чисел, над которыми осуществляются все четыре арифметических действия. Тогда обработчик bbRunClick мог бы быть таким:

procedure Tform1.bbRunClick(Sender: TObject);

procedure Output(Operation: Char);

//Осуществляет нужное действие и выводит результат в mmOutput

+0peration+
‘(‘+
Forma tFloat(‘+0.0000;-0.0000’,у.re)+
FormatFloat(‘+0.OOOOj;-0.OOOOj’,у.im)+’=’+
FormatFloat(‘+0.0000;-0.0000’,z.re)+
FormatFloat(‘+0.OOOOj;-0.OOOOj’,x.im);

Обратите внимание на ссылку uses cmpix в самом начале исполняемой части — именно она делает доступными обработчику bbRunClick объекты модуля Cmplx. Эту ссылку можно вставить с помощью среды Delphi: выберите опцию File | Use Unit и в появившемся окне щелкните по имени модуля Сmplx.

12.7. ТИПЫ МОДУЛЕЙ В DELPHI

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

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

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

Модули динамических библиотек предназначены для создания широко используемых в Windows динамически связываемых библиотек DLL (Dynamic-Link Libraries). DLL служат универсальным средством согласования подпрограмм, написанных на разных языках программирования. В Windows содержится множество DLL, написанных на языке Си или на языке ассемблера, что ничуть не мешает Delphi-программам использовать их. Модули динамических библиотек предназначены для разработки DLL с помощью Object Pascal. Такие DLL затем смогут использовать программы, созданные с помощью других языков программирования.

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

Модули потоков предназначены для реализации так называемых потоков команд[ В Delphi существуют также потоки данных — см.п. 11.4.] — фрагментов программы, которые исполняются параллельно с другими фрагментами, разделяя с ними время процессора и остальные системные ресурсы. Механизм потоков используется в 32-разрядных Windows и не поддерживается в Delphi 1. К сожалению, в текущей реализации Delphi 32 потоки не могут связываться с собственными видимыми компонентами, так как библиотека визуальных компонентов VCL (Visual Component Library) не поддерживает работу с потоками. Вот почему модуль потока не имеет связанного с ним окна.

Структура модуля. Структура файла головной программы приложения Delphi;

Структура файла головной программы приложения Delphi

ЯЗЫК ОБЪЕКТНО-ОРИЕНТИРОВАННОГО ПРОЕКТИРОВАНИЯ OBJECT PASCAL

Возможности объектно-ориентированного проектирования в Delphi базируют­ся на свойствах языка Object Pascal.

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

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

Типичная головная программа приложения имеет вид:

Unit1 in ‘Unit1.pas’ ,

Unit2 in ‘Unit2,pas’ ;

Начинается программа с ключевого слова program,после которого пишется имя программы. Оно совпадает с именем файла, в которым вы сохранили свой про­ект. Это же имя присваивается выполняемому файлу приложения. По умолчанию это имя Project1.

После заголовка в тексте программы располагается предложение uses.В этом предложении перечисляются модули, загружаемые программой. Первый модуль Forms— системный. А следующие — модули разработанных вами форм. Данный пример подразумевает, что вы создали в проекте две формы с именами Form1 и Form2в модулях с именами Unit1 и Unit2.Помещенные в фигурные скобки на­звания форм — это комментарии.

Следующая строка текста — <$R *.BES>представляет собой директиву ком­пилятора. Затем после ключевого слова beginи до последнего завершающего программу оператора end с точкой (end.) записано тело программы.

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

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

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

interface // Открытый интерфейс модуля

(Список подключаемых модулей) uses

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

TForml = class(TForm) private // Закрытый раздел класса

public // Открытый раздел класса

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

implementation // Реализация модуля

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

Читать еще:  Как обрезать картинку в css

Модуль начинается с ключевого слова unit,после которого пишется имя моду­ля. Оно совпадает с именем файла, в котором вы сохранили свой модуль. По умол­чанию для первого модуля имя равно Unit1,для второго Unit2 — и т.д.

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

В разделе interfaceпосле предложения uses, содержащего список подключае­мых модулей, вы можете видеть заготовку объявления класса вашей формы, под­готовленную Delphi. Имя класса вашей формы — TForml.Класс содержит два раз­дела: privateзакрытый раздел класса, и publicоткрытый раздел класса. То, что вы или Delphi объявите в разделе public,будет доступно для других клас­сов и модулей. То, что объявлено в разделе private,доступно только в пределах данного модуля.

После завершения объявления класса формы вы можете видеть строки

Это объявляется переменная Formlкласса TForml,т.е. объявляется ваша форма как объект класса TForml.

Затем следует пока пустой раздел реализации implementation,в котором со­держится только директива компилятора. Следите за тем, чтобы случайно не стереть эту директиву.

В модуль вы можете ввести еще два раздела, кроме interface и implementati­on:разделы initialization и finalization.

Модули. Структура модуля. Стандартные модули Delphi .

Структура модуля.

Модули – одно из ключевых понятий языка Паскаль. Они предназначены для разбиения проекта на части. В каждом модуле могут быть собраны константы, типы, переменные, процедуры и функции, объединенные по смысловому признаку. Например, модуль для работы с комплексными числами или со стеком. Модуль представлен отдельным файлом с расширением *. pas . Скомпилированный модуль имеет расширение *. dcu . Для добавления в проект Delhi нового модуля необходимо выполнить команды File -> New -> Unit . После выполнения этой команды на отдельной закладке редактора кода появляется заготовка модуля:

Модуль по умолчанию будет называться Unit 1. Причем, в файл программы в раздел подключения модулей uses будет добавлено соответствующее имя модуля. Это имя будет автоматически изменяться при сохранении модуля под другим именем.

Unit1 in ‘Unit1.pas’;

Формальная структура модуля выглядит так:

После заголовка, содержащего служебное слово unit и идентификатор имени модуля (имя модуля и имя файла с расширением pas , в котором записан модуль, должны обязательно совпадать), идет внешний раздел interface (интерфейсная часть модуля). Все, описанное в этом разделе, доступно из программы и других модулей, использующих этот модуль. В интерфейсной части описываются только заголовки процедур и функций – имя и список формальных параметров. Тело (текст) этих подпрограмм должно находиться в следующей части модуля, после слова implementation . В разделе interface могут быть подключены другие модули с помощью служебного слова uses . Перекрестные ссылки модуля на модуль в интерфейсной части запрещены (модуль А подключает модуль В, а модуль В подключает модуль А). При необходимости, для избежания перекрестных ссылок их можно сделать в исполнительной части.

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

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

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

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

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

Листинг модуля Lib . pas

x , y : Real ;// координаты точки x и y

Function Distance(d1,d2:Tdot):real; // расстояние между точками d1 и d2

Function SquareT ( d 1, d 2, d 3: Tdot ): real ; // площадь треугольника, заданного 3-мя точками

var a, b, c, p : Real;

a := Distance ( d 1, d 2); // находим расстояние между точками d 1 и d 2

b := Distance ( d 2, d 3); // находим расстояние между точками d 2 и d 3

c := Distance ( d 3, d 1); // находим расстояние между точками d 3 и d 1

Result := Sqrt(p * ( p – a ) * ( p – b ) * ( p – c ) );

Листинг программы TesLib , использующей модуль Lib . pas

Lib ; // подключение модулей SysUtils и Lib

var a, b, c : Tdot;

write ( ‘ Введите координаты X и Y 1-й вершины треугольника — ’ );

write ( ‘ Введите координаты X и Y 2-й вершины треугольника — ’ );

write ( ‘ Введите координаты X и Y 3-й вершины треугольника — ’ );

s := SquareT(a, b, c);

writeln (‘Площадь треугольника = ’, s :6:2);

p:= Distance(a, b)+ Distance(b, c)+ Distance(c, a);

writeln (‘Периметр треугольника = ’, p :6:2);

Пример модуля, реализующего стек с целыми числами.

Приведем пример модуля Steck , который содержит минимальный набор процедур и функций для работы со стеком и сами данные. Стек можно организовать на основе массива из целых чисел M . Для контроля над заполнением массива новыми значениями введем целочисленную переменную top , которая всегда будет хранить номер свободной ячейки массива. Причем данные опишем в исполнительной части массива, исключив прямое обращения к ним из программы, использующей модуль. Обращаться к ним будем только с помощью процедур и функций. Таким скрытием данных можно дополнительно гарантировать корректность работы пользователя со стеком (при прямом неправильном изменении переменной top можно потерять некоторые данные из стека, например оператор top :=0 очистит весь стек). Пользователям, подключающим модуль необходимо предоставить методы для работы со стеком: поместить число в стек, извлечь число из стека, проверить стек на пустоту и т.д. Эти процедуры и функции необходимо поместить в интерфейсную часть модуля. Так как, структура хранения данных стека не доступна из программы, то физическая реализация стека может быть совершено различной: динамический массив, связный список. Но программы, которые будут использовать этот модуль не должны изменяться при изменении реализации стека. Они будут пользоваться одним и тем же набором процедур и функций, описанных в интерфейсной части. То есть при изменении способа реализации стека интерфейсная часть модуля остается неизменной, а меняется текст и данные в исполнительной части.

Структура стека на базе массива изображена на рис.1. Новый элемент будет добавляться на место с номером top , после этого top необходимо увеличить на единицу. При извлечении элемента из стека top уменьшается на единицу и из этой позиции извлекается очередное число. Теперь эта позиция считается пустой. Стек пустой – если значение top равно 0. Для инициализации стека (его очистки) достаточно переменной top присвоить 0. В программе извлечение числа из пустого стека приведет к ошибке, поэтому перед такой операцией пользователь должен убедиться, что в стеке есть элементы. Стек организуем на базе динамического массива. Его размер можно увеличивать по мере заполнения стека новыми значениями. Массив окажется полностью заполненным, если число элементов совпадет с top . Это необходимо проверять перед добавлением нового элемента.

Рис.1 Структура стека на базе массива

Листинг модуля Steck .

Procedure Push ( x : integer ); // Поместить число х в стек.

Function Pop : integer ; // Извлечь число из стека.

Procedure InitSteck ; // Очистить стек.

Function IsEmpty : Boolean ; // Результат True – если стек пустой.

Var M:array of integer;

Procedure Push(x:integer); // Поместить число х в стек .

if top=High(M) then SetLength(M, Length(M)+20);

Информационные технологии 1

Программирование на Delphi

1. Введение

На нашем курсе мы будем изучать Delphi 7, наиболее стабильную версию языка программирования для Win32 – то есть 32-разрядных версий Windows. Появились и новые версии Delphi, но они ориентированны на технологию .NET, за которую начинающим программистам браться рановато. Тем более, что эта технология еще не применяется широко, и рынок программного обеспечения, созданного с помощью Delphi, все равно составляют программные продукты, написанные на Delphi 7, и даже более ранних версий.

Основу Delphi составляет не только сам язык, но и RAD (Rapid Application Development) – среда быстрой разработки программ . Благодаря визуальному программированию, а также достаточно большой библиотеке визуальных компонентов, Delphi позволяет создавать программы наиболее быстро и эффективно, принимая на себя основную работу, и оставляя программисту творческий процесс. Разумеется, возможность быстрого создания профессиональных приложений для Windows делает Delphi – программистов востребованными во всех отраслях человеческой деятельности.

Читать еще:  Язык си массивы примеры

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

Традиционно при изучении программирования принято создавать первую программу, которая выводит текст «Hello, world!». Не будем отступать от традиции и создадим программу, которая выводит этот текст тремя разными способами. Но вначале познакомимся с самой средой программирования Delphi. Предполагается, что на этот момент Delphi 7 уже установлена на вашем ПК. Если это не так, то перед дальнейшим прочтением лекции установите Delphi 7. При загрузке Delphi 7 вы видите такую картину:

Рис. 1.1. Рабочая среда Delphi 7

Познакомьтесь – это Delphi. У нее есть много окон, панелей, компонентов. С большинством из них мы познакомимся со временем, а пока нам нужно обратить внимание на 5 окон:

  1. Главное окно Delphi. Здесь находится основное меню, различные панели инструментов и палитра компонентов, состоящая из множества вкладок.
  2. Конструктор формы. Здесь мы визуально видим, как будет выглядеть форма программы, здесь мы будем создавать интерфейс, перенося на форму различные компоненты, и расставляя их таким образом, чтобы интерфейс выглядел привлекательным. Нам часто придется переключаться между конструктором форм и редактором кода, делается это клавишей F12.
  3. Редактор кода. Здесь мы видим исходный код программы, который создан самой Delphi. Тут же мы будем вводить наш собственный код.
  4. Объектный инспектор. Он предназначен для управления объектами проекта и состоит из двух вкладок – Properties (Свойства) и Events (События).
  5. Дерево объектов. Здесь мы видим, какой именно объект в данный момент является текущим. Это окно будет особенно полезно, когда на форме появится множество компонентов.

Когда открывается Delphi, она автоматически создает и отображает новый проект (программу). На рисунке вы видите проект , который содержит только одну стандартную форму . Форма – это тоже объект, который представляет собой окно программы. Чтобы программа делала что-то полезное, нам придется вносить изменения в нее. Выведем текст «Hello, world!» первым способом. Для этого в инспекторе объектов найдите свойство Caption. В данный момент текущим является объект – форма , и свойство Caption формы отвечает за надпись на системной строке программы (синяя полоса вверху любого программного окна). По умолчанию, свойство Caption содержит надпись «Form1», также называется и сама форма. Измените эту надпись на «Hello, world!» (конечно, без кавычек). Уже в процессе ввода текста вы видите, что надпись в системной строке принимает новый вид. Мы ввели этот текст одним способом.

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

    Выбираем команду меню «File – Save All» (сохранить все), либо нажимаем горячие клавиши , либо нажимаем одноименную кнопку на панели инструментов

Рис. 1.2. Кнопки Save (Сохранить) и Save All (Сохранить всё) на панели инструментов

  • Затем выходит окно с предложением сохранить модуль – текстовый файл с исходным кодом, принадлежащий форме. Файл имеет расширение *.pas. Имеем в виду, что каждый проект сохраняется в отдельную папку, поэтому вначале щелкнем правой кнопкой мыши по свободному месту окна с папками, и выберем команду «Создать — Папку». Дадим папке какое-либо имя, например, «01». После создания папки открываем ее.
  • Далее в поле «Имя файла» укажем имя сохраняемого модуля. Имя может быть любым, но обязательно латинскими символами. Еще имя модуля не должно совпадать с именем формы. Обычно, имена формам и модулям стараются делать информативными, то есть, по имени можно будет догадаться, что это за файл. Поскольку это главная форма проекта, дадим ей имя «Main», и нажмем кнопку «Сохранить».
  • Затем нам будет предложено дать имя проекту в целом. Имя проекта будет совпадать с именем исполняемого программного файла. Если мы хотим, к примеру, получить файл «hello.exe», то дадим проекту имя «hello». Нажмем кнопку «Сохранить».
  • Далее нам необходимо скомпилировать программу, то есть, перевести исходный код в выполняемый exe-файл. Для этого мы можем выбрать команду меню «Run — Run», либо нажать горячую клавишу F9, либо нажать кнопку «Run» на панели инструментов (на кнопке изображение зеленой стрелки, указывающей вправо). В результате, программа была не только скомпилирована, но и запущена. Если вы посмотрите на системную строку Delphi, то увидите надпись «Delphi 7 – hello [Running]», а окна инспектора объектов и дерева объектов исчезли. Это говорит о том, что программа находится в режиме выполнения. Выполняемая программа имеет точно такой же вид, как наша главная форма, только на форме отсутствует точечная сетка, предназначенная для облегчения дизайна. Окно полученной программы содержит все стандартные кнопки Windows – программы. Щелкнув по красному крестику в правой верхней части окна, закройте программу (но не Delphi), и вы увидите прежнюю форму.

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

    Попробуем второй способ. Обратите внимание на Палитру компонентов . Текущей является вкладка Standard , и на ней находится множество значков – компонентов. Когда вы подводите указатель мыши к какому-либо компоненту, через некоторое время выскакивает подсказка с именем компонента. Нам нужен компонент Label , который представлен на вкладке в виде кнопки с изображением жирной буквы «А». Щелкните по этой кнопке, затем щелкните по свободному месту на форме, чтобы вставить компонент. Лучше, если вы расположите его ближе к левому верхнему краю формы. Компонент Label появился на форме. Этот компонент представляет собой обычную надпись. Сейчас он выделен, и содержит надпись по умолчанию, — «Label1». Теперь объектный инспектор показывает свойства этого компонента, а не формы. Label также имеет свойство Caption , которое вы можете изменить в Инспекторе объектов. Найдите это свойство, и вместо «Label1» впишите «Hello, world!». Текст в компоненте Label изменился. Если вам не нравится место, в котором оказался компонент, вы можете перетащить его мышью на другое место. Кроме того, точное местоположение компонента вы можете задать, если выделите его, и будете нажимать клавиши перемещения курсора, удерживая при этом клавишу . Теперь попробуйте еще одно свойство компонента Label – свойство Font (шрифт). Найдите это свойство в инспекторе объектов, и выделите его. Справа появится кнопочка с тремя точками, нажмите ее. Откроется стандартное окно выбора шрифта. Здесь вы можете выбрать имя шрифта, его размеры, начертание (например, жирный курсив) и цвет текста. Поэкспериментируйте с размером компонента, его положением и шрифтом. Почти все компоненты, с которыми нам придется иметь дело, имеют эти свойства, так что в дальнейшем вам будет легче осваивать новый компонент.

    Снова сохраните проект и нажмите кнопку Run (или ). Убедитесь, что надпись появилась на форме, после чего закройте программу (но не Delphi) и вернитесь к форме.

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

    Для начала нужно установить на форму кнопку. Этот компонент также находится на вкладке Standard палитры компонентов, и выглядит как кнопочка с надписью «ОК». При наведении на него указателя мыши выскакивает подсказка «Button». Щелкнув по компоненту, щелкните затем по тому месту на форме, где вы хотели бы видеть эту кнопку. Изменим надпись на кнопке. Убедитесь, что кнопка выделена, и найдите в инспекторе объектов ее свойство Caption. Замените надпись «Button1» на «Нажми меня!». Если надпись не умещается на кнопке, вы можете растянуть кнопку мышью, или использовать для этого клавиши управления курсором с нажатой кнопкой .

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

    Ссылка на основную публикацию
    ВсеИнструменты 220 Вольт
    Adblock
    detector