Краткий курс программирования в среде Delphi


языки программирования

Краткий курс программирования в среде Delphi

(для студентов заочной формы обучения специальности 7.050201 «Менеджмент организаций» специализации «Информационные системы в менеджменте «)

Данный курс предназначен для изучения дисциплины «Языки программирования» студентами, обучающимися по специальности «Менеджмент организаций» специализации «Информационные системы в менеджменте».

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

После знакомства с теоретическим курсом, студенты должны овладеть основными принципами алгоритмизации, основными понятиями языка Object Pascal — алфавит, словарь языка, структура программы, типы данных, операторы, основами визуального программирования, основами объектно-ориентированного программирования.

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

Раздел И ЗНАКОМСТВО С СРЕДОЙ DELPHI

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

После запуска Delphi на экране появляются наиболее важных и окна

Delphi:

1 — главное окно; 2 — окно формы;

3 — окно Деревья объектов (Object Tree View) 4 — окно Инспектора объектов;

5 — окно кода программы.

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

главное окно

 

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

Рис.1 — Главное окно Delphi

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

Для изменения состава показанных на панельке кнопок нужно предварительно щелкнуть по ней правой кнопкой мыши. В окне вспомогательного появившемся после этого, перечисленные названия всех панелек и указанный их статус (отмечены флажками панельки, что видны в главном окне; если отметку убрать, панелька исчезнет). После выбора Customize (Настройка) появится окно настройки). Теперь можно «взимать» с панелек ненужные кнопки, выбирать из списка в окне commands (закладка Commands) нужные кнопки и перетаскивать их на экран.

 

Рис.2 Настройка инструментальных панелек: окно вспомогательного меню с названиями всех панелей.

 

Рис.3 — Настройка инструментальных панелек: окно настройки с выбранной закладкой Command

В главном окне располагается:

— главное меню Delphi;

— набор пиктографических командных кнопок;

— палитра компонентов.

— главное меню

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

 

 

Рис.4 — Главное меню

 

пиктографические кнопки

 

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

Группа Standard

Открывает доступ к Репозитория Объектов.Эквивалент опции File | New | Other

Открывает существующий файл.Эквивалент опции File | Open File

Сохраняет файл на диске.Эквивалент опции File | Save File (клавиши быстрого доступа Ctrl-S)

Сохраняет все файлы проекта.Эквивалент опции File | Save All

Открывает созданный ранее проект программы.Эквивалент опции File | Open Project (клавиши быстрого доступа Ctrl-F11)

Добавляет новый файл в проект.Эквивалент опции Project | Add to project (клавиши быстрого доступа Shift-F11)

Удаляет файл из проекта.Эквивалент опции Project | Remove from Project

Группа View

Выбирает модуль из списка модулей, связанных с текущим проектом.Эквивалент опции View | units (клавиши быстрого доступа Shift-F12)

Выбирает форму из списка форм, связанных с текущим проектом.Эквивалент опции View | Forms (клавиши быстрого доступа Ctrl-F12)

Переключение активности между окном формы и окном кода программы.Эквивалент опции View | Toggle Form / Unit (клавиша быстрого доступа F12)

Создает новую форму и добавляет ее к проекту.Эквивалент опции File | New | Form

Группа Debug

Компилирует и выполняет программу.Эквивалент опции Run | Run (клавиша быстрого доступа F9)

Реализует паузу в работе настраиваемый программы.Эквивалент опции Run | Program Pause

Осуществляет пошаговое трассировки программы по прослеживанием работы вызванных подпрограмм.Эквивалент опции Run | Trace into (клавиша быстрого доступа F7)

Осуществляет пошаговую трасировку программы, но не прослеживает работу вызванных подпрограмм.Эквивалент опции Run | Step Over (клавиша быстрого доступа F8)

Группа Custome

Открывает доступ к встроенной справочной службы.Эквивалент опции Help | Delphi Help

 

 

 

Delphi

Группа Desktops

 

Список выбора возможных вариантов настройки других окон

 

Сохраняет текущее настройки окон Delphi

Выбирает настройки окон, соответствует режиму налаживание

Группа Internet

Начинает создание нового программного средства по технологии WebSnap (для Интернет)

Создает новую страницу программного средства WebSnap

Создает новый модуль программного средства WebSnap

 

палитра компонентов

 

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

 

Рис.5 — Палитра компонентов.

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

после щелчка правой кнопкой мыши на любой пиктограмме в палитре компонентов и выбора опции properties (Свойства)

Наиболее часто используемые компоненты рассмотрены в Приложении.

 

окно формы

 

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

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

 

Рис.6 — Окно формы

 

Окно дерева о объектов

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

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

 

Рис.7 — Окно дерева о объектов

 

Окно инспектора о объектов

 

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

— Properties (Свойства) и Events (События). Страница properties используется для установления нужных свойств компонента, страница Events позволяет определить реакцию компонента на то или иное событие. Совокупность свойств отражает видимую сторону компонента: положение относительно левого верхнего угла рабочей области формы, его размеры и цвет, шрифт и текст надписи на нем и т.п .; совокупность событий — его поведенческую сторону: будет ли компонент реагировать на щелчок мыши или на нажатие клавиш, как он будет вести себя в момент появления на экране или в момент изменения размеров окна и т.п.

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

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

Строки таблицы выбираются щелчком мыши и могут отображать простые или сложные свойства. К простым относятся свойства, обусловленные единственным значением — числом, строкой символов, значением True (Истина) или False (Ложь) и т.п. Например, свойство Caption (Заголовок) представляется строкой символов, свойства Height (Высота) и Width (Ширина) — числами, свойство Enabled (Доступность) — значениями True или False. Сложные свойства определяются совокупностью значений. Слева от имени таких свойств указывается значок «+», а щелчок мышью по этому символу приводит к раскрытию списка составляющей сложного свойства. Чтобы закрыть раскрыт список, нужно щелкнуть по значку «-» сложного свойства.

 

 

Рис.8 — Окно Инспектора о объектов.Страница Properties (Свойства) и страница Events (События)

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

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

Если Вы случайно или намеренно сделаете окно невидимым, нажмите F11 или выберите опцию View | Object inspector, чтобы оно снова появилось на экране.

Окно кода программы

 

Окно кода предназначено для создания и редактирования текста программы. Этот текст состоит по специальным правилам и описывает алгоритм работы программы. Совокупность правил записи текста называется языком программирования. В системе Delphi используется язык программирования Object Pascal, который представляет собой расширенную и усовершенствованную версию широко распространенного языка Паскаль, впервые предложенной швейцарским ученым Н. Виртом еще в 1970 и усовершенствованной сотрудниками корпорации Borland (созданные ими языка назывались Turbo Pascal, Borland Pascal и Object Pascal). Несмотря на то, что визуальная среда Delphi берет на себя многие рутинные аспекты программирования, знание языка Object Pascal является непременным условием для любого программиста, который работает в этом среде.

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

Сразу после открытия нового проекта в окне кода будут такие строки:

unit Unit1; interface uses

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

type

TForm1 = class (TForm)

 

 

 

 

 

var

private

{Private declarations}

public

{Public declarations}

end;

 

Form1: TForm1;

implementation

{SR *.DFM}

end.

Эти строки Delphi автоматически вставляет в окно кода для новой формы. Окно кода определяет поведенческую сторону окна программы (т.е. окна появляется после начала работы программы), а окно формы — внешние проявления. Оба окна тесно связаны друг с другом, причем Delphi «хозяйничает» в его верхней части, вставляя необходимые строки между

unit Unit1;

и

implementation

Мы будем вставлять текст программы между строками

{$ R- *.DFM}

и

end.

в нижней части окна.

Чтобы вставить в окно новую строку (строки), нужно сначала с помощью клавиш курсора или щелкнув по окну мышью, поставить курсор на нужное место, а затем с помощью клавиатуры ввести текст. Конечно текст кода программы располагается в нескольких строках. Для перехода на новую строку используйте клавишу Enter. Если в процессе ввода Вы ошиблись и сразу заметили свою ошибку, удалите ложный символ клавишей Backspace. Клавиша Backspace удаляет символ слева от курсора, а клавиша Delete — справа от него. Если понадобится удалить сразу всю строку текста, поставьте в любое место строки курсор, нажмите клавишу Ctrl и, не отпуская ее, клавишу с латинской буквой Y. Такое совместное нажатие клавиш в дальнейшем будем обозначать символом «+»: Ctrl + Y. чтобы отменить последнюю

изменение текста, нажмите Ctrl + Z или выберите Edit | Undo.

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

 

Рис.9 — Окно кода с расположенным слева браузером Code Explorer

 

 

В нижней части окна кода расположены две закладки — Сode и Diagram. Щелчок мышью по последней активизирует страницу диаграмм. Сначала эта страница пуста.

раздел II

Основы языка программирования OBJECT PASCAL

 

типы данных

 

 

порядковые типы

 

В этих типах информация представляется в виде отдельных элементов. Связь между отдельными элементами и их представлением в памяти определяет естественные отношения порядка между этими элементами. Отсюда и название — порядковые.

 

В Object Pascal определены три группы порядковых типов и два типа, определяемые пользователем. Группы — это цели, символьные и булевы типы. Порядковые типы, задаваемые пользователем, — это перечисления и поддиапазона. Все значения любого порядкового типа образуют упорядоченную последовательность, и значение переменной порядкового типа определяется его местом в этой последовательности. За исключением переменных целых типов, значения которых могут быть более или менее нуля, первый элемент любого порядкового типа имеет номер 0, второй элемент — номер 1 и т.д.

Таблица 1 — Операции над порядковыми типами

 

операция описание
Low (T) Минимальное значение порядкового типа Т
High (T) Максимальное значение порядкового типа Т
 

 

Ord (X)

Порядковый номер значения порядкового типа. Для целого выражения — просто его значение. Для других порядковых типов Ord возвращает физическое представление результата выражения, трактуется как целое число. Возвращаемого значения, всегда принадлежит одному из целых типов
Pred (X) Предварительное значение. Для целых выражений эквивалентно Х-1
Succ (X) Следующее значение. Для целых выражений эквивалентно Х + 1
Dec (V) Уменьшает значение переменной на 1. Эквивалентно V = Pred (V)
Inc (V) Увеличивает значение переменной на 1. Эквивалентно V = Succ (V)

 

 

цели типа

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

Integer Shortint Smallint Longint Byte Word Cardinal

Таблица 2 — Физические цели типа

 

Тип диапазон значения физический формат
Shortint От -128 до 127 8 бит, со знаком
Smallint От -32 768 до 32 767 16 бит, со знаком
Longint От -2147483648 до 2147483647 32 бит, со знаком
Byte От 0 до 255 8 бит, без знака
Word От 0 до 65535 16 бит, без знака

 

Диапазоны значений и форматы физических целых типов не зависящие от микропроцессора и операционной системы, в которых выполняется программа. Они не меняются с изменением реализации или версии Object Pascal.

Диапазоны значений логических целых типов (Integer и Cardinal) определяются совсем другим способом. Они никак не связаны с диапазонами соответствующих физических типов.

Таблица 3 — Поиск цели типа

 

Тип диапазон значений физический формат
Integer -32 768-32 767 16 бит, со знаком (SmalInt)
Integer -2147483 648-2 147 483 647 32 бит, со знаком (Longint)
Cardinal 0-65 535 16 бит, без знака (Word)
Cardinal 0-2 147483647 32 бит, без знака (Longint)

 

Над целыми данным выполняются все операции, определенные для порядковых типов, но с ними все-таки удобнее работать как с числами, а не с «немногочисленными порядковыми типами». Как и обычные числа, данные целых типов можно составлять (+), вычитать (-) и умножать (*). Однако некоторые операции и функции, применяемые к данным целых типов, имеют несколько иной смысл.

Таблица 4 — Операции над целыми типами

 

операция результат
Abs (X) Возвращает абсолютное целое значение Х
Х Div Y Возвращает целую часть результата деления Х на Y
Х Mod Y Возвращает остаток деления Х на Y
Odd (X) Возвращает булево True (истина), если Х — нечетное целое, и False (ложь) — в противном при
Sqr (X) Возвращает целый квадрат Х (т.е. Х * Х)

символьные типы

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

Физические типа:

AnsiChar — однобайтные символы упорядочены согласно расширенного набора символов ANSI (American National Standards Institute — Американский национальный институт стандартов)

WideChar — Символы объемом в слово, упорядоченные в соответствии с международным набора символов UNICODE. Первые 256 символов совпадают с символами ANSI

Логический символьный тип называется char.

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

Применяемые функции:

Chr (X) — превращает целую переменную в переменную типа char с тем же порядковым номером. В Delphi это эквивалентно задаче типа Char (X)

UpCase — превращает строчную букву в прописную.

 

булевы типы

Если информация о чем-либо можно представить как ИСТИНА (True) или ЛОЖЬ (False), то в Object Pascal она хранится в переменных булевых типов. Всего таких типов четыре.

Таблица 5 — Размеры переменных булевых типов

 

Тип Размер
Boolean 1 байт
ByteBool 1 байт
WordBool 2 байт (объем Word)
LongBool 4 байт (объем Longint)

Переменным типа Boolean можно присваивать только значение True (истина) и False (ложь). Переменные ByteBool, WordBool и LongBool могут принимать и другие порядковые значения, интерпретируются обычно как False в случае нуля и True — при любом ненулевом значении.

перечислительная типы

Описание типов, перечисляются:

Type NameType = (first value, value2, value3, last value)

Пример. Можно создать тип MyColor (мой цвет) со значениями myRed, myGreen и myBlue (мой красный, мой зеленый, мой синий). Это делается так:

Type MyColor = (myRed, myGreen, myBlue)

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

— 1 и т.д.

 

Пиддиапазонни типа

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

Type subrange type = low value … high value;

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

 

Действительные типы

 

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

Таблица 6 — действительные типы

 

Тип порог максимальное значение Количество значащих цифр объем

(Байт)

Real 2.9E-39 1.7Е38 11-12 6
Single 1.5E-45 3.4Е38 7-8 4
Double 5.0E-324 1.7Е308 15-16 8
Extended 3.4E-4932 1.IE4932 19-20 10
Comp 1.0 9.2Е18 19-20 8
Currency 0.0001 9.2Е14 19-20 8

 

Таблица 7 — Функции действительных типов:

 

функция Возвращаемого значения
Abs (x) Абсолютная величина х
АгсТаn (х) арктангенс х
Cos (x) Косинус х (х выражается в радианах, а не в градусах)
Ехр (х) Экспоненциальная функция от х
Frac (x) Дробная часть х
 

Int (x)

Целая часть х. Несмотря на название, возвращает истинное значение (с плавающей запятой), то есть просто устанавливает ноль в дробной части
Ln (x) Натуральный логарифм от х
Pi Число Пи (3,1416 …)
 

 

 

Round (x)

Ближе всего к х целое значение. Возвращает значение целого типа. Условие «ближе к х» не работает, если верхнее и нижнее значения оказываются равновиддаленимы (например, если дробная часть точно равна 0,5). В этих случаях Delphi переводит решение в операционную систему. Конечно процессоры Intel решают эту задачу в соответствии с рекомендацией IEEE округлять в сторону ближайшего четного целого числа. Иногда такой подход называют «банкирским округлением»
Sin (x) синус х
Sqr (x) Квадрат х, то есть X * X
Sqrt (х) Квадратный корень от х
Тrunc (х) Целая часть х. В отличие от Int, что возвращает истинное значение, Trunc возвращает целое

срочные типы

 

В выражениях Delphi поддерживает три физических срочных форматы: короткий

(ShortString), длинный (LongString) и широкий (WideString).

 

Таблица 8 — Срочные функции

 

функция описание
Concat (sl, s2, s3) Возвращает последовательное соединение строк.

Эквивалентна оператору sl + s2 + s3

Copy (s, pos, len) Возвращает подстроку длиной максимум len

символов, начинающаяся в позиции pos строки s

Delete (s, pos, len) Удаляет максимум len символов из строки s,

начиная с позиции pos

Insert (sourse, target, pos) Вставляет строку source в строковую переменную target,

начиная с позиции pos

Length (s) Возвращает динамическую длину строки.
Pos (substring, s) Возвращает место первого вхождения подстроки

substring в строку s.

SetLength (s, newlen) Задает новую динамическую длину newlen срочной переменный s
SetString Задает содержание и длину строки
Str (x, s) превратит численное значение х в строковую переменную s
StringOfChars Возвращает строку с конкретным числом символов
UniqueString Делает данную строку уникальным со счетом обращений 1
Val (s, v, code) Преобразует строку s в соответствующее численное представление v
Процедуры и функции для работы со строками, содержащихся в модуле SisUtils
IntToStr (Value: Integer): String Преобразования значения целочисленного выражения

Value в строку

StrToInt (const S: String): Integer Преобразование строки S в целое число
FloatToStr (Value: Extended): String Преобразования значения действительного выражения Value в строку
StrToFloat (const S: String): Extended Преобразование строки S в действительное число
UpperCase (const S: String): String Перевод символов строки S в верхний регистр
LowerCase (const S: String): String Перевод символов строки S в нижний регистр
Trim (const S: String): String Удаление из начала и конца строки S пробелов и управляющих символов
TrimLeft (const S: String): String Удаление с начала строки S пробелов и управляющих символов
TrimRight (const S: String): String Удаление в конце строки S пробелов и управляющих символов

записи

 

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

record

fieldname1: fieldtype1;

fieldname2, fieldname3: fieldtype2;

case optional tagfield: required ordinal type of 1: variantname1: varianttype3;

2, 3: variantname2: varianttype4; end;

Данное объявление состоит из фиксированной и вариантной частей. Однако вовсе не обязательно вставлять в одно объявление записи обе эти части, конечно удобнее работать с каждой из этих частей отдельно.

фиксированные записи

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

record

fieldname1: fieldtype1;

fieldname2, fieldname3: fieldtype2; end;

Имея доступ к информации в записи, можно обрабатывать всю запись целиком (все поля одновременно) или только отдельное поле. Для обращения к отдельному поля необходимо набрать имя записи, точку и идентификатор поля, например:

MyRec.Fieldname1

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

 

вариантные записи

Вариантная часть типа record дает возможность по-разному трактовать область памяти, совместно занимаемую вариантами поля:

record

case optional tagfield: required ordinal type of 1: variantnamel: varianttype3;

2, 3: variantname2: varianttype4; end;

 

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

массивы

 

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

например:

array [ordinal_type] of type_definition;

array [ordinal_typel, ordinal_type2] of type_definition;

Каждый массив содержит некоторое количество элементов информации одного типа. Число элементов массива в каждом измерении задается порядковым типом (ordinal_type). Для этого можно воспользоваться идентификатором некоторого типа (например, Boolean или AnsiChar), однако на практике, конечно, явно задается поддиапазон целых. Количество элементов массива равна произведению количеств элементов во всех измерениях. Для обращения к элементу массива указывается имя этого массива и индекс элемента в квадратных скобках.

Например:

массив определен следующим образом:

var MyArray: Array [1..10] of Integer;

Тогда обращение к его третьего элемента будет выглядеть, как MyArray [З],

и выполняться, как к переменной Integer.

 

Множество

 

Зарезервированное слово set (множество) определяет множество не более чем из

256 порядковых значений:

Set of ordinal type

Минимальный и максимальный порядковые номера исходного типа (на основе которого определяется множественный тип) должны быть в пределах между 0 и 255. Переменная множественного типа содержит (или не содержит) любое значение выходного порядкового типа. Каждое значение из заданного диапазона может принадлежать или не принадлежать ни множественном числе.

пример:

MyAlphaSet = [ ‘А’, ‘Е’, ‘I’, ‘В’, ‘U’, ‘Y’]; // Все прописные гласные.

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

файловый тип

 

Тип file предназначен для доступа к линейной последовательности элементов.

Объявления файлового типа:

 

file of Type1 // Файл определенного типа, содержащий запись фиксированной длины.

file // Файл без типа.

Text file // Файл с текстовыми записями переменной длины, разделенными

// символами CR и LF ( «возврат каретки» и «перевод строки»).

 

 

В Delphi файловая структура — это переменная.

указательные типы

 

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

Пример объявления переменных-указаний:

Var p1: pointer // Указание без типа.

p2: ^ Integer // Указание с типом.

Таблица 9 — Средства работы с указаниями:

 

средство описание
New Распределяет новый участок динамической памяти и записывает ее адрес в переменную указательного типа
 

оператор @

Направляет переменную-указание на область памяти, содержащую любую существующую переменную, процедуру или функцию, включая переменные, имеющие идентификаторы
GetMem Создает новую динамическую переменную заданного объема и записывает ее адрес в переменную указательного типа

 

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

Зарезервированное слово Nil указывает значение указания, которая ни на что не указывает.

Такие указания называют неопределенными.

 

Структура программ Delphi

 

Любая программа в Delphi состоит из файла проекта (файл с расширением dpr) и одного или нескольких модулей (файлы с расширениями pas). Каждый из таких файлов описывает программную единицу Object Pascal.

структура проекта

 

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

Delphi и щелкнуть по опции Project | View Source главного меню. Delphi покажет окно кода с закладкой Project1, содержащий следующий текст:

program Project1;

uses

Forms, Unit1 in ‘Unit1.pas’ {fmExample};

{$ R *.RES}

begin

Application.Initialize; Application.CreateForm (TfmExample, fmExample) Application.Run;

end.

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

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

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

{$ R *.RES}

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

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

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

Например:

{Это комментарий}

(* Это тоже комментарий *)

// Все символы до конца этой строки составляют комментарий

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

строки:

uses

Forms, Unit1 in ‘Unitl.pas’ {fmExample};

указывают, что кроме файла проекта в программе должны использоваться модули Forms и Unit1. Модуль Forms является стандартным (то есть уже известным Delphi), а модуль Unit1 — новым, ранее неизвестным, и Delphi в этом случае указывает также имя файла с текстом модуля (in ‘uniti.pas «) и имя связанного с модулем файла описания формы {fmExample}.

Собственно тело программы начинается со слова begin (начать) и ограничивается терминатором end с точкой. Тело состоит из нескольких операторов языка Object Pascal.  В каждом операторе реализуется некоторое действие — изменение значения

переменной, анализ результата вычисления, обращение к подпрограмме и т.п. В теле нашей программы — три оператора:

Application.Initialize; Application.CreateForm (TfmExample, fmExample) Application.Run;

Каждый из них реализует обращение к одному из методов объекта Application.

Объектом называется специальным образом оформленный фрагмент программы, заключает в себе данные и подпрограммы для их обработки. Данные называются полями объекта, а подпрограммы — его методами. Объект в целом предназначен для решения какой-либо конкретной задачи и воспринимается в программе как неделимое целое (то есть, нельзя из объекта «выдернуть» отдельное поле или метод). Объекты играют чрезвычайно важную роль в современных языках программирования. Они придуманы для того, чтобы увеличить производительность труда программиста и одновременно повысить качество разрабатываемых им программ. Две главные свойства объекта — функциональность и неделимость — делают его самостоятельной или даже самодостаточной частью программы и позволяют легко переносить объект из одной программы в другую. Разработчики Delphi придумали сотни объектов, которые можно рассматривать как кирпичики, из которых программист строит многоэтажный дом программы. Такой принцип построения программ называется объектно — ориентированным программированием (ООП). В объекте Application собраны данные и подпрограммы, необходимые для нормального функционирования Windows-приложения в целом. Delphi автоматически создает объект-программу Application для каждого нового проекта.

строка

Application.Initialize;

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

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

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

 

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

Заголовок открывается зарезервированным словом Unit за которым следует имя модуля и точка с запятой. Секция интерфейсных объявлений открывается зарезервированным словом Interface, а секция реализации — словом implementation. Терминатором модуля, как и терминатором программы, является end с точкой. Следующий фрагмент программы является синтаксически верным вариантом модуля:

unit Unit1;

interface

// Секция интерфейсных объявлений

implementation

// Секция реализации

end.

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

Щелкнув по закладке Unit1 окна кода, можно увидеть следующий текст:

unit Unit1; interface uses

Windows, Messages, SysUtils, Classes, Graphics, Controls,

 

Forms, Dialogs, StdCtrls, Buttons, ExtCtrls; type

TfmExample = class (TForm) Panel1: TPanel;

bbRun: TBitBtn; bbClose: TBitBtn; edinput: TEdit; IbOutput: TLabel; mmOutput: TMemo; private

{Private declarations} public

{Public declarations} end; var

fmExample: TfmExample; implementation

$ R *.DFM}

end.

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

В интерфейсной секции описаны один тип (класс — fmExample) и один объект

(Переменная fmExample).

Вот описание класса:

type

TfmExample = class (TForm) Panell: TPanel;

bbRun: TBitBtn; bbClose: TBitBtn; edinput: TEdit; IbOutput: TLabel; mmOutput: TMemo;

private

{Private declarations} public

{Public declarations} end;

Классы служат главным инструментом реализации мощных возможностей Delphi. Класс является образцом, по которому создаются объекты, и наоборот, объект — это экземпляр реализации класса. Образцы для создания элементов программы в Object Pascal называются типами, таким образом, класс TfmExamplel -это тип. Перед его объявлением расположено зарезервированное слово type (тип), оповещающий компилятор о начале раздела описания типов.

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

TfmExample = class (TForm)

в котором за зарезервированным словом class в скобках указывается имя родительского класса. Термин «продажной» означает, что класс TfmExample унаследовал все возможности родительского класса TForm и добавил к ним собственные в виде дополнительных компонентов, мы вставили в форму fmExample. Перечень вставленных нами компонентов и составляет значительную часть описания класса.

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

Объект fmExampie формально относится к элементам программы, называются переменными. Вот почему перед объявлением объекта расположено зарезервированное слово var (от англ. Variables — переменные).

элементы программы

 

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

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

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

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

Константы определяют области памяти, не могут менять своего значения в ходе работы программы. Для объявления имен констант используется зарезервированное слово const. Например:

const

k = 10;

Переменные связаны с областями памяти, меняются. Впереди раздела объявление переменных должно стоять слово var. Например:

var

j: Integer; m: Byte;

Метки — это имена операторов программы. Метки используются для того, чтобы указать компилятору, оператор программы должен выполняться следующим. Перед разделом объявлений меток идет зарезервированное слово label. Например:

label Loop; begin

Goto Loop;

// Программист требует передать управление

// оператору, обозначенному меткой Loop. …..

// Эти операторы будут пропущены

Lоор: // Оператору, следующего за этой меткой, будет передано управление

end;

 

Подпрограммы — это специальным образом оформленные фрагменты программы.

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

Итак, структуру программы в общем случае можно представить так:

Program <имя программы>; Uses <Список модулей>; Label <Список меток>;

Const <Список констант>; Type <Описание типов>;

Var <Объявления переменных>;

<Описание процедур>;

<Описание функций>; Begin

<Операторы>; End.

 

Операторы языка

 

 

оператор присваивания

 

В Object Pascal для присваивания переменной определенного значения или выражения используется сочетание символов =, например:

Х = 123; Y = 2 * X-35;

составной оператор

 

Составной оператор — это последовательность произвольных операторов программы, заключенная в операторные скобки — зарезервированные слова begin … end.

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

условный оператор

 

Условный оператор позволяет проверить некоторое условие и в зависимости от результатов проверки выполнить то или иное действие. Условный оператор — это средство ветвления вычислительного процесса.

Структура условного оператора выглядит следующим образом: if <условие> then <оператор1> else <оператор2>;

где if / then / else — зарезервированные слова (если, то, иначе)

<Условие> — произвольное выражение логического типа;

<Оператор1>, <оператор2> — любые операторы языка Object Pascal.

Условный оператор работает по следующему алгоритму. Сначала вычисляется условное выражение <условие>.  Если результат есть True (истина), то

выполняется <оператор1>, а <оператор2> пропускается; если результат есть False (ложь), наоборот, <оператор1> пропускается, а выполняется <оператор2>.

Например:

var

X, Y, Max: Integer; begin.

if X> Y then Max = X else Max = Y;

… end;

<Оператор1> и <оператор2> могут быть составными операторами. Например:

var

X, Y, Max, Min: Integer; begin.

if X> Y then begin

Max = X; Min = Y;

end else

begin Max = Y; Min = X;

end;

… end;

 

Кроме операций отношения =, <>>,> =, <, <= условие в условном операторе может содержать сложные логические выражения, которые используют логические операции and (логическое И), or (логическое ИЛИ) и not (логическое НЕ).Например:

if (a> b) and (b <> 0) then …

if (l> m) or (m <> 0) then …

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

if a> b and b <> 0 then …// Ошибка

 

Части else <оператор2> условного оператора может не быть. Тогда при значении True условного выражения выполняется <оператор1>, в противном случае этот оператор пропускается.

35

 

пример:

var

X, Y, Max: Integer; begin

if X> Y then Мах = X;

… end;

 

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

оператор выбора

 

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

— выражение любого порядкового типа (например, integer, char и т.д.).

Структура оператора выбора:

case <ключ_вибору> of

<Список_вибору> else <операторы> end;

Здесь case, of, else, end — зарезервированные слова.

<Ключ_вибору> — ключ выбора (выражение порядкового типа);

<Список_вибору> — одна или более конструкций вида:

<Константа_вибору> <оператор>;

<Константа_вибору> — константа того же типа, что и выражение <ключ_вибору>;

<Оператор> — произвольный оператор Object Pascal.

Оператор выбора работает так:

сначала вычисляется значение выражения <ключ_вибору>, а затем в последовательности операторов <список_вибору> выполняется поиск такого, которому предшествует константа, равная вычисленному значению. Найденный оператор выполняется, после чего оператор выбора завершает свою работу. Если в списке выбора не будет найдена константа, соответствующая вычисленному значению ключа выбора, то управление передается операторам, расположенных по слову else.  Часть else <операторы> может отсутствовать.  Тогда при отсутствии в

 

список выбора нужной константы ничего не произойдет и оператор выбора просто завершит свою работу.

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

var

ch: Char; begin

case ch of

«N», «N», «H», «H»: IbOutput.Caption = «Нет»;

«В», «В», «д», «Д»: IbOutput.Caption = «Да»; else IbOutput.Caption: = ‘ошибка ввода’; end

end;

Операторы повторений

 

В языке Object Pascal есть три различных операторы, с помощью которых можно запрограммировать повторяющиеся фрагменты программ.

Счетный оператор цикла FOR;

Оператор цикла WHILE с предварительной проверкой условия; Оператор цикла REPEAT … UNTIL с постперевиркою условия.

 

Счетный оператор цикла FOR имеет следующую структуру:

for <параметр цикла> = <поч_знач> to <кон знач> do

<Оператор>;

Здесь for, to, do — зарезервированные слова (для, до, выполнить)

<параметр_циклу> — переменная типа Integer (или любого другого порядкового типа);

<Поч_знач> — начальное значение — выражения того же типа;

<Кин_знач> — конечное значение — выражения того же типа;

<Оператор> — произвольный оператор Object Pascal. Если оператор составленный его необходимо принимать в операторные скобки Begin …End.

При выполнении оператора for сначала вычисляется выражение <поч_знач> и осуществляется присваивание <параметр_циклу> = <поч_знач>. После этого циклически повторяется: проверка условия <параметр_циклу> <= <кин_знач>;

если условие не выполнено, оператор for завершает свою работу; далее осуществляется выполнение оператора <оператор>; затем наращивание переменной

<Параметр_циклу> на единицу.

Условие, руководит работой оператора for, проверяется перед выполнением оператора <оператор>: если условие не выполняется в самом начале работы оператора for, оператор, выполняется, не будет выполнена ни разу.

Шаг наращивания параметра цикла строго постоянен и равен (1),

однако существует другая форма оператора:

for <параметр_цик> = <поч_знач> downto <кин_знач> do

<Оператор>;

В этом случае шаг наращивания параметра цикла равен (-1), а управляющая условие: <параметр               цикла>> = <кин_знач>.

пример:

Sum: = 0;

if N> = 0 then

for i: = 1 to N do Sum = Sum + i else

for i = -1 downto N do Sum = Sum + i;

Этот фрагмент программы производит подсчет положительных или отрицательных чисел в зависимости от значения N.

 

Оператор цикла WHILE с предварительной проверкой условия имеет следующую структуру:

while <условие> do <оператор>;

 

 

Здесь while, do — зарезервированные слова (пока выполняется условие, делать)

<Условие> — выражение логического типа;

<Оператор> — произвольный оператор Object Pascal. Если оператор составленный его необходимо принимать в операторные скобки Begin …End.

Если выражение <условие> имеет значение True, то выполняется <оператор>, после чего вычисление выражения <условие> и его проверка повторяются.если

<Условие> имеет значение False, оператор while прекращает свою работу.

 

 

Оператор цикла REPEATUNTIL с постперевиркою условия имеет следующую структуру:

repeat <тело цикла> Until <условие>;

 

 

Здесь repeat, until — зарезервированные слова (повторять до тех пор, пока не будет выполнено условие)

<Тело_цикла> — произвольная последовательность операторов Object Pascal;

<Условие> — выражение логического типа.

Операторы <тело_цикла> выполняются хотя бы один раз, после чего вычисляется выражение <условие>: если его значение является False, операторы

<Тело_цикла> повторяются, в противном случае оператор repeat … until

завершает свою работу.

Обратите внимание: пара repeat … until подобная операторные скобки begin … end, поэтому перед until ставить точку с запятой необязательно.

Для гибкого управления циклическими операторами for, while и repeat в состав Object Pascal включены две процедуры без параметров:

break — реализует немедленный выход из цикла; действие процедуры заключается в передаче управления оператору, который расположен сразу за концом циклического оператора;

continue — обеспечивает досрочное завершение очередного прохода цикла; эквивалент передачи управления в самый конец циклического оператора.

Метки и операторы перехода

 

Оператор перехода имеет вид:

goto <метка>;

здесь goto — зарезервированное слово (перейти на метку)

<Метка> — метка.

Метка в Object Pascal — это произвольный идентификатор, позволяющий именовать некоторый оператор программы и таким образом ссылаться на него.

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

Действие оператора goto заключается в передаче управления соответствующем намеченному оператору.

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

подпрограммы

 

 

Основные сведения о подпрограммы

 

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

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

Работа с подпрограммой распределяется на два этапа:

 

— описание подпрограммы;

— вызов подпрограммы.

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

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

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

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

— с использованием файлов;

— с помощью глобальных переменных

— с помощью параметров.

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

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

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

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

Подпрограммы можно вызвать не только из программы, но и из других подпрограмм.

процедуры

 

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

Procedure <имя> (формальные параметры)

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

Рассмотрим в качестве примера процедуру обработки события нажатия кнопки Button1, в которой, в свою очередь, вызываются две процедуры DecodeDate и ChangeStr.

procedure TForm1.Button1Click (Sender: TObject);

// Описание пользовательской процедуры ChangeStr

procedure ChangeStr (var Source: string; const charl, char2: char)

label 10;

var n: integer; begin

10:

n = pos (char1, Source) if n> 0 then

begin Source [n] = char2; goto 10;

end;

end;

var str1: string;

Year, Month, Day: word; begin

// Вызов процедуры DecodeDate DecodeDate (Now, Year, Month, Day) Str1 = Edit1.Text;

// Вызов пользовательской процедуры ChangeStr ChangeStr (strl, ‘1’, ‘*’);

Edit1.Text: = str1; end;

Процедура DecodeDate, служащий для разложения дать на отдельные составляющие (год, месяц и день), может быть использована без предварительного описания, потому что она уже описана в модуле SysUtils. Процедура ChangeStr выполняет замену в строке Source всех вхождений символа задает параметр char1, в символ, задается параметром char2.

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

Вызов процедуры ChangeStr обеспечивает замену везде в строке str1

символа 1 в символ *.

 

функции

 

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

Function <Имя> (Формальные параметры) <Тип результата>;

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

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

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

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

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

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

procedure TForm1.Button1Click (Sender: TObject);

// Описание функции ChangeStr2

function ChangeStr2 (Source: string; const char1, char2: char): string;

label 10;

var n: integer; begin Result: = Source; 10:

n = pos (char1, Result); if n> 0 then

begin

Result [n] = char2; goto 10;

end; end;

var str1: string; n: integer;

begin str1 = Edit1.Text;

// Вызов функции ChangeStr2 str1 = ChangeStr2 (str1, ‘1’, ‘*’); Edit1.Text: = str1;

// Вызов функции Length

n = Length (str1) end;

Функция Length возвращает длину строки и может быть использована без предварительного описания, поскольку она содержится в модуле System. Функция ChangeStr2 выполняет те же действия, что и процедура ChangeStr из предыдущего примера. Вызов функции используется в операторе присваивания.

рекурсивные подпрограммы

 

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

Рассмотрим, например, вычисление факториала числа:

 

function Fact (n; integer): integer; begin

if n <= 0 then Fact: = 1 else Fact = n * Fact (nl) end;

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

Функция Fact () и ее параметр имеют тип Integer, соответствующую типу Longint и позволяет вычислять факториал для достаточно небольших значений n (не более 31).Для увеличения диапазона значений можно использовать настоящие типы, например, Real.

Параметры и аргументы

 

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

значения;

константа; переменная;

нетипизированного константа и переменная.

Группа параметров, перед которыми в заголовке подпрограммы отсутствуют слова var или const и за которыми следует их тип, называются параметрами-значениями. Например, а и g являются параметрами-значениями в следующем описании:

procedure P1 (a: real; g: integer);

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

Группа параметров, перед которыми в заголовке подпрограммы расположено слово const и за которыми следует их тип, называются параметрами-константами. Например, в описании:

procedure P2 (const х, у: integer);

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

Группа параметров, перед которыми в заголовке подпрограммы расположено слово var и за которыми следует их тип, называются параметрами переменными.

Например, параметрами-переменными d и f в следующем описании:

function F1 (var d, f: real; ql7: integer): real;

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

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

function F2 (var e1; const t2): integer;

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

 

модули

 

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

Модуль состоит из заголовка, в котором после ключевого слова unit указывается имя модуля, и четырех разделов: интерфейса (interface), реализации (implementation), инициализации (initialization) и деинициализацию (Finalization).

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

 

Unit <Имя модуля>;

// Раздел интерфейса

Interface

Uses <Список модулей>; Const <Список констант>; Type <Описание типов>;

Var <Объявления переменных>;

<Заголовки процедур>;

<Заголовки функций>;

// Раздел реализации

Implementation

Uses <Список модулей>;

Const <Список констант>; Type <Описание типов>;

Var <Объявления переменных>;

<Описание процедур>;

<Описание функций>;

// Раздел инициализации

Initialization

<Операторы>

// Раздел деинициализацию

Finalization

<Операторы> End.

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

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

В разделе инициализации располагаются операторы, выполняемые в начале

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

При наличии раздела инициализации в модули можно использовать раздел деинициализацию, начинающийся словом Finalization и есть

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

раздел III

ОСНОВЫ визуального программирования

 

Основные концепции визуального программирования в Delphi

 

Программирование в Delphi строится на взаимодействии двух процессов: процесса конструирования визуального проявления программы (т.е. ее Windows-окна) и процесса написания кода, добавляет элементам этого окна и программе в целом необходимую функциональность. Для написания кода используется окно кода, для конструирования программы — другие окна Delphi, прежде всего — окно формы.

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

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

49

 

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

 

 

Пустая форма и ее модификация

 

Как уже говорилось, окно формы содержит проект Windows-окна программы. Важно помнить, что с самого начала работы над новой программой Delphi создает минимально необходимый код, который обеспечивает ее нормальное функционирование в Windows. Таким образом, самая программа готова сразу после выбора опции File | New | Application.

Изменение свойств формы

 

изменение заголовка

Изменим заголовок окна программы. По умолчанию (то есть без каких-либо усилий с нашей стороны) заголовок окна совпадает с заголовком формы: Form1. Чтобы изменить заголовок формы нужно обратиться к окну Инспектора объектов и щелкнуть мышью по строке Caption (Заголовок) страницы Properties (Свойства) окна Инспектора объектов. Теперь правый столбик этой строки с текстом Form1 выделен цветом и справа от выделения видим текстовый курсор. Переключите клавиатуру в режим ввода кириллицы и введите новый заголовок, например МОЯ ПЕРВАЯ ПРОГРАММА, затем запустите программу (нажмите F9).Новый прогон программы создаст окно с заголовком МОЯ ПЕРВАЯ ПРОГРАММА, что несет в себе гораздо больше информации, чем просто Form1.

Итак, простой сменой содержания строки в окне Инспектора объектов можно изменить одно из свойств окна.

Изменение цвета формы

Изменим цвет окна программы. По умолчанию он совпадает с цветом формы. Чтобы изменить цвет формы нужно обратиться к окну Инспектора объектов и щелкнуть мышью по строке Color (Цвет) на странице

 

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

Размещение нового компонента

 

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

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

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

Новый компонент имеет стандартное имя Label1 и надпись на нем повторяет это имя. Изменить эту надпись можно с помощью строки Caption окна Инспекториа объектов. Для этого надо ввести новый надпись (например, Delphi) в правый столбик этой строки. Как только Вы начнете вводить надпись, вид компонента на форме начнет меняться, динамично отражая все изменения, сделанные Вами в окне Инспектора объектов.

 

Рис.10 — Размещение компонента Label

 

Выделим надпись цветом и сделаем его шрифт более крупным. Для этого щелкнем мышью по свойству Font окна Инспектора объектов и с помощью кнопки в правой части строки раскроем диалоговое окно настройки шрифта. В списке size (размер) этого окна выберите высоту шрифта 24 пункта (пункт — 1/72 дюйма, то есть примерно 0,04 мм, таким образом, 24 пункта означает высоту шрифта чуть более 9 мм), а с помощью списка Color (Цвет) выберем нужный цвет (например, красный), после чего закроем окно кнопкой ОК.

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

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

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

них (в этот момент показатель меняет свою форму на двунаправленный стрелку),

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

Все видимые компоненты Delphi (в Delphi могут использоваться как видимые, так и невидимые компоненты. Невидимые компоненты не имеют визуального отображения на этапе прогона программы) имеют свойства Left (слева), Тор (Сверху), Width (Ширина) и Height (Высота), числовые значения которых определяют положение левого верхнего угла компонента и его размеров в так называемых пикселях, то есть в минимальных по размеру точках экрана, светимостью которых может управлять программа.При перемещении компонента или изменении его размеров мышью, эти значения автоматически меняются и, наоборот, изменение этих свойств в окне Инспектора объектов приводит к соответствующему изменению положения и размеров компонента.

реакция на события

 

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

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

— «кнопку», и заставим ее реагировать на событие — нажатие левой кнопки мыши.

Компонент «кнопка» изображается пиктограммой на странице Standard палитры компонентов.Разместите этот компонент на форме и расположим его ниже метки и внутри формы.

Рис.11 — Форма с вставленной кнопкой

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

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

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

procedure TForm1.Button1Click (Sender: TObject);

begin end;

Слово procedure сообщает компилятор о начале пидпрограми- процедуры (в Delphi могут использоваться также подпрограммы-функции, в этом случае вместо procedure (процедура) используется слово function (функция)). За ним следует имя процедуры TForm1.Button1Click. Это имя составлено: оно состоит из имени класса TForm1 и собственно имени процедуры Button1Click.

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

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

type

TForm1 = class (TForm) Button1: TButton; Label1: TLabel;

procedure Button1Click (Sender: TObject);

private

{Private declarations}

public

{Public declarations}

end;

var Form1: TForm1;

 

строка

TForm1 = class (TForm)

определяет новый класс TForm1, что порожденный (создан по образцу) от стандартного класса TForm.

строка

Form1: TForm1;

создает экземпляр этого класса с именем Form1. Стандартный класс TForm описывает пустое Windows-окно, тогда как класс TForm1 описывает окно с уже вставленными в него компонентами метка и кнопка.Описание этих компонентов содержат строки

Button1: TButton; Label1: TLabel;

Они указывают, что компонент Button1 (Кнопка1) представляет собой экземпляр стандартного класса TButton, а компонент Label1 (Метка 1) — экземпляр класса TLabel.

По имени процедуры TForm1.Button1Click в круглых скобках идет описание параметра вызова Sender: TObject

Параметр с именем Sender принадлежит классу TObject. процедуры могут

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

 

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

всю строку

procedure TForm1.Button1Click (Sender: TObject);

в целом называется заголовком процедуры. его завершает символ «; «.Этот символ играет важную роль в Object Pascal, так как показывает компилятору на конец предложения языка. Из отдельных предложений состоит весь текст программы. В конце каждого предложения надо ставить точку с запятой — это обязательное требование синтаксиса языка.

Следующие строки определяют тело процедуры:

begin end;

Слово begin (начало) сигнализирует компилятору о начале последовательности предложений, описывающих алгоритм работы процедуры, а слово end (конец) — о конце этой последовательности.В нашем случае тело процедуры пока еще не содержит описания любых действий, и неудивительно: Delphi только создает заготовку для процедуры, и ничего «не знает» о том, для чего эта процедура предназначена. Наполнить тело процедуры -задача программиста.

Теперь при нажатии кнопки Button1 управления будет передаваться в тело процедуры.Между словами begin и end можно написать фрагмент программы, которая будет выполняться в ответ на это событие.

Например, сделаем нашу кнопку «звучащий»: напишем в пустой строке между словами begin … end следующее предложение:

MessageBeep (0);

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

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

Динамическое изменение свойств компонента

 

Поскольку кнопка Button1 в нашей программе способна «звучать», полезно изменить ее надпись: вместо надписи Button1, автоматически формирует Delphi по имени компонента, назовем кнопку, например, «Звук».Проще всего это сделать с помощью окна формы и Инспектора объектов, то есть на этапе конструирования формы (для этого нужно просто изменить свойство Caption компонента Button1 в окне Инспектора объектов), но мы рассмотрим другой способ — динамическое изменение надписи на этапе прогона программы.Изменения на этапе конструирования называются статическими, а в ходе прогона программы — динамичными. Для динамического изменения надписи создадим обработчик события OnCreate (По созданию) для формы и изменим в нем это свойство.

Событие OnCreate возникает после создания windows-окна, но до появления этого окна на экране.Чтобы создать обработчик этого события, необходимо раскрыть список компонентов в верхней части окна Инспектора объектов, выбрать компонент Form1 и дважды щелкнуть по свойству OnCreate на странице Events этого компонента (щелкать нужно по правой части строки onСreate).В ответ Delphi снова активизирует окно кода и покажет заготовку для процедуры TForm1.FormCreate.Необходимо отредактировать ее следующим образом:

procedure TForm1.FormCreate (Sender: TObject); begin

Button1.Caption: = ‘Звук’; end;

Единственный вставлен строку представляет собой оператор присваивания языка Object Pascal. В левой части оператора указывается свойство Button1.Caption, а в правой части — значение ‘звук’, что мы хотим дать этому свойству.Связывает обе части комбинация символов «=», что читается как «присвоить значение».   Символы «=» всегда пишутся слитно, без

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

Составное имя Button1.Caption необходимо для точного указания компилятору, о которой свойство идет речь: в нашей программе используются три компонента (включая саму форму), каждый из которых имеет свойство Caption; уточняющий префикс Button1 заставит изменить это свойство в кнопки, а не в метки или формы.Значение, присваиваемое свойства, является текстовой строкой. По правилам Object Pascal текстовую строку должен заключаться в апострофы, обрамляющие. Внутри апострофов можно написать произвольные символы — именно они (без апострофов, обрамляющие) будут определять новый надпись на кнопке.

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

Итак,

— Процесс создания Delphi-программы разбивается на две фазы: фазу конструирования формы и фазу кодирования.

— Конструирование формы осуществляется с помощью выбора компонентов из палитры и размещения их на форме.

— Программист может перемещать любой размещен на форме компонент и изменять его размеры с помощью мыши.

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

— Чтобы компонент мог откликаться на то или иное событие, программист должен создать обработчик события и указать его имя на странице Events Инспектора объектов.

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

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

— Тело процедуры ограничено словам begin … end и состоит из предложений (операторов) языка Object Pascal.В конце каждого предложения ставится точка с запятой.

— Для предоставления компонента надлежащей функциональности надо написать соответствующий код в окне кода.

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

 

Раздел I V ОСОБЕННОСТИ Объектно ориентированного

ПРОГРАММИРОВАНИЕ

 

Основные концепции ООП

 

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

Базой ООП являются:

— инкапсуляция;

— наследования;

 

— полиморфизм.

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

Наследование это процесс порождения новых объектов-потомков от

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

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

Пример объявления нового класса:

TAnyClass = class (TParentClass)

// Добавление к классу TParentClass новых и переопределения существующих

// элементов end;

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

 

классы и о объекты

 

В языке Object Pascal классы — это специальные типы данных, используемые для описания объектов.Согласно об объект, имеющий тип любого класса, является экземпляром этого класса или переменной этого типа.

Класс представляет собой особый тип записи, имеет в своем составе такие элементы (члены), как поля, свойства и методы.

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

Описание класса имеет следующую структуру:

Type <Имя класса> = class (<Имя класса-отца>) private

<Частные описания>; protected

<Защищенные описания>; public

<Общедоступные описания>; published

<Опубликованные описания>; end;

В приведенной структуре описаниями является объявление свойств, методов и событий.

Пример описания класса:

type

TColorCircle = class (TCircle)

FLeft, FTop, FRight, FBottom: Integer; Color: TColor;

end;

Здесь класс TColorCircle создается на основе родительского класса TCircle.По сравнению с родительским, новый класс дополнительно содержит четыре поля типа integer и одно поле типа TColor.

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

type TNewClass = class

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

Разделы private и protected содержат защищены описания, доступных внутри модуля, в котором они находятся.Описания из раздела protected, кроме того, доступны для порожденных классов за пределами названного модуля.

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

Раздел published содержит опубликованы описания, в дополнение к общедоступным описаний порождают динамическую (то есть во время выполнения программы) информацию о типе (Run-Time Type Information, RTTI).По этой информации при выполнении приложения выполняется проверка на принадлежность элементов объекта той или иной класса. Одним из назначений раздела published является обеспечение доступа к свойствам объектов при конструировании приложений.В Инспекторе объектов видны те свойства, которые являются опубликованными. Если спецификатор published не указан, то он подразумевается по умолчанию, поэтому любые описания, расположенные за строкой с указанием имени класса, считаются опубликованными.

Объекты как экземпляры класса появляются в программе в разделе var как обычные переменные.Например,

var

CCircle1: TColorCircle; CircleA: TCircle;

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

Пример обращения к полям объекта

var

CCircle1: TColorCircle; begin

… Ccircle1.FLeft = 5; Ccircle1.FTop: = 1;

… end;

Здесь приведено непосредственное обращение к полям объекта, обычно это делается с помощью методов и свойств класса.

поля

 

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

Пример описания полей:

type TNewClass = class (TObject) private

FCode: integer; FSign: char; FNote: string; end;

Здесь новый класс TNewClass создается на основе базового класса TObjec t и получает в дополнение три новых поля FCode, FSign и FNote, имеющих соответственно целочисленный, символьный и строковый типы.Согласно принятой соглашением имена полей должны начинаться с префикса F (от англ.Field — поле).

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

Напомним, что изменение значений полей обычно выполняется с помощью методов и свойств объекта.

свойства

 

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

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

Пример описания свойств:

type TNewClass = class (TObject) private

FCode: integer;

FSign: char:

FNote: string; published

property Code: integer read FCode write FCode; property Sign: char read FSign write FSign;

property Note: string read FNote write FNote; end;

Для доступа к полям FCode, FSign и FNote, что описаны в защищенном разделе и недоступны другим классам, используются свойства Code, Sign и Note, соответственно.

методы

 

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

Например, описание метода Button1Click будет выглядеть так:

interface

… type

TForm1 = class (TForm)

Button1: TButton;

procedure Button1Click (Sender: TObject);

end;

… implementation

procedure TForm1.Button1Click (Sender: TObjectit)

begin Close; end;

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

virtual — виртуальный метод, dynamic — динамический метод, override — переопределяемой метод, message — обработка сообщения; abstract — абстрактный метод.

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

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

Прежде чем обращаться к элементам объекта, его нужно создать с

помощью конструктора. Например:

Object = TOwnClass.Create;

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

При выполнении конструктора часто также осуществляется инициализация

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

Пример использования конструктора и деструктора:

type

TShape = class (TGraphicControl) private

FPen: TPen;

procedure PenChanged (Sender: TObject); public

constructor Create (Owner: TComponent) override; destructor Destroy; override;

end;

// Описание конструктора Create класса TShape constructor TShape.Create (Owner: TComponent) begin

inherited Create (Owner); // Инициализация унаследованных частей Width = 65; // Изменение унаследованных свойств Height = 65;

FPen = TPen.Create; // Инициализация новых полей

FPen.OnChange = PenChanged; end;

В конструкторе класса-потомка сначала вызывается конструктор отца, а затем выполняются другие действия. В классе-потомке директива override (переопределить) обеспечивает возможность родительском класса использовать новый метод.Ключевое слово inherited служит для вызова методов родительского класса.

Сообщения и события

 

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

Type

PMsg = TMsg;

Msg = packed record hwnd: HWND;

message: UINT; wParam: WPARAM; lParam: LPARAM; time: DWORD; pt: TPoint

end;

 

Поля этой записи содержат следующую информацию:

hwnd — дескриптор управляющего элемента, которому предназначено сообщение;

message — код сообщения;

wParam и lParam — Дополнительная информация о сообщении;

time — время обработки сообщения Windows;

pt — координаты показателя мыши во время генерации сообщения.

Система Delphi превращает сообщение свой формат, для которого используется запись следующего типа:

PMessage = ^ TMessage; TMessage = record Msg: Cardinal;

case Integer of 0: (

WParam: Longint; LParam: Longint; Result: Longint) 1: (

WParamLo Word; WParamHi Word; LParamLo Word; LParamHi Word; ResultLo Word; ResultHi Word) end;

Типы Msg, TMessage, а также константы, использованные при посылке сообщений описаны в файлах widows.pas и message.pas.

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

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

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

Рассмотрим в качестве примера обработку сообщения Windows,

ссылается при изменении размеров окна.

type

TForm1 = class (TForm)

// Объявление метода обработки сообщения procedure MyPaint (Var Param) message WM_Size; end;

// Код метода обработки сообщения procedure TForm1.MyPaint (Var Param) begin

// Вызов метода-предка

inherited;

// Очистка поверхности формы

Form1.Refresh;

// Вывод красной рамки Form1.Canvas.Pen.Color = clRed; Form1.Canvas.Brush.Style = bsClear;

Form1.Canvas.Rectangle (0,0, Form1.ClientWidth, Form1.ClientHeight) end;

По периметру формы выводится красная рамка по помощью

процедуры MyPaint, что является обработчиком сообщения WM_size.Это сообщение посылается при изменении размеров окна. В данном примере рамка перерисовывается (вместе с формой) только при изменении размеров окна, но не при его перекрытии другими окнами, так как в этом случае посылается сообщение WM_Paint, что здесь не анализируется.Параметр Param процедуры нигде не используется, но должен быть указан в заголовке процедуры.

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

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

Пример назначения обработчика события:

Application. OnIdle = IdleWork;

Как обработчика события OnIdle, что возникает при простое программы, объекта программы назначается процедура Idlework.Потому что объект Application доступен только при выполнении программы, то такое присваивания нельзя выполнить через Инспектор объектов.

События Delphi имеют различные типы, зависят от вида этого события.Самым простым является тип TNotifyEvent, что характерно для нотификационные (уведомляющих) событий.Этот тип описан следующим образом:

type TNotifyEvent = procedure (Sender: TObject) of object;

и содержит один параметр sender, что указывает объект-источник события.Многие события более сложного типа, наряду с другими параметрами, также имеют параметр Sender.

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

Кроме параметров, явно задаются, например, параметра Sender, метода всегда передается показатель на его экземпляр класса, вызвал.Этим показателем является параметр Self.

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

функция

SendMessage (hwnd: HWND; Msg: Cardinal; WParam, LParam: Longint): Longint

посылает сообщение оконном элемента управления, ссылки (дескриптор) на который задана параметром hwnd.В Delphi дескриптор оконного элемента содержит свойство Handle.Параметр Msg указывает код сообщения, а параметры WParam и LParam содержат дополнительную информацию о сообщениях, и их значения зависят от конкретного сообщения.

пример:

 

Label1.Caption = IntToStr (SendMessage (ListBox1.Handle, LB_GetCount, 0, 0));

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

 

список литературы

 

 

1. Архангельский А.Я.Приемы программирования в Delphi (Bepcu 5-7) .-

М.: Бином, 2003. 784с.

2. Архангельский А.Я.Программирование в Delphi 6. М.: Бином, 2003. 1120с.

3. Гофман В.Э., Хомоненко А.Д. Delphi 5.- СПб .: БХВ — Санкт-Петербург, 1999.

— 800с.

4. Гофман В.Э., Хомоненко А.Д. Delphi 6.- СПб .: БХВ — Санкт-Петербург, 2001.

— 1152с.: Ил.

5. Гусева А. И.Учимся программировать Pascal 7.0. Задачи и методы их решения. — М .: Диалог МИФИ, 2003. 256с.

6. Культин Н.              Основы программирования Delphi 7. -СПб.: ВНУ-Санкт

Петербург, 2003. 608с.

7. Понамарев В.Самоучитель Delphi 7 Studio — CПб.: ВНУ-Санкт-Петербург, 2003. 512с.

8. Фаронов В.В. Delphi 3: Учебный курс. — М .: «Нолидж», 1998. -526с.

 

 

Приложение.

палитра компонентов

Приложение Палитра компонентов

 

 

В Палитру компонентов входят следующие страницы: Страница STANDARD

Страница ADDITIONAL страница WIN32 страница SYSTEM страница DIALOGS страница WIN 3.1 Страница SAMPLES страница ACTIVEX

Компоненты для работы с базами данных: Страница DATA ACCESS

Страница DATA CONTROLS страница DBEXPRESS страница DATASNAP страница BDE

страница ADO

Страница INTERBASE страница DECISION CUBE страница QREPORT

Компоненты для доступа в Интернет: Страница INTERNET

Страница FASTNET страница WEBSERVICES страница WEBSNAP

Страницы INDY CLIENTS, INDY SERVERS, INDY MISC

 

НАЧАЛО STANDARD

На странице Standard палитры компонентов расположены стандартные для Windows интерфейсные элементы, без которых не обходится практически ни одна программа.

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

MainMenu — главное меню программы. Компонент способен создавать и обслуживать сложные иерархические меню.

PopupMenu — вспомогательное или локальное меню. Обычно это меню появляется в отдельном окне по нажатию правой кнопки мыши.

Label — метка. Этот компонент используется для размещения в окне не очень длинных однострочных надписей.

Приложение Палитра компонентов

Edit — строка ввода. Предназначена для ввода, отображения и редактирования текстового строки.

Memo — многострочный текстовый редактор. Используется для ввода и / или отображения многострочного текста.

Button — командная кнопка. Обработчик события OnClick этого компонента обычно используется для реализации некоторой команды.

CheckBox — независимый переключатель. Щелчок мышью на этом компоненте в работающей программе меняет его логическую свойство Checked.

RadioButton — зависимый переключатель. Обычно сочетается как минимум еще с одним таким же компонентом в группу. Щелчок по переключателю приводит к автоматическому освобождению ранее выбранного переключателя в той же группе.

ListBox — список выбора. Содержит список предлагаемых вариантов (опций) и дает возможность проконтролировать текущий выбор.

ComboBox — комбинированный список выбора. Представляет собой комбинацию списка выбора и текстового редактора.

ScrollBar — полоса управления. Представляет собой вертикальную или горизонтальную полосу, напоминает полосы прокрутки по бокам

Windows-окна.

GroupBox — группа элементов. Этот компонент используется для группировки нескольких связанных по смыслу компонентов.

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

Panel — панель. Этот компонент, как и GroupBox, служит для объединения нескольких компонентов. Содержит внутреннюю и внешнюю кромки, позволяет создать эффекты «вдавленность» и «выпуклости».

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

НАЧАЛО ADDITIONAL

BitBtn — командная кнопка с надписью и пиктограммой.

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

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

StringGrid — таблица строк. Этот компонент имеет мощные возможности для представления текстовой информации в табличном виде.

DrawGrid — произвольная таблица. В отличие от StringGrid организации этого компонента могут содержать произвольную информацию, в том числе рисунки.

Image — рисунок. Этот компонент предназначен для отображения рисунков, в том числе пиктограмм и метафайлов.

Shape — фигура. С помощью этого компонента Вы можете вставить в окно правильную геометрическую фигуру — прямоугольник, эллипс, окружность и т.п.

Приложение Палитра компонентов

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

ScrollBox — панель с полосами прокрутки. В отличие от компонента Panel автоматически вставляет полосы прокрутки, если размещенные в нем компоненты отсекаются его границами.

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

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

StaticText — статический текст. Отличается от стандартного компонента Label наличием собственного windows-окна позволяет обводить текст рамкой или выделять его в виде и «вдавленной» части формы.

ControiBar — полоса управления.

ApplicationEvents — получатель события. Если этот компонент помещен на форму, он будет получать все предназначенные для программы сообщения Windows (без этого компонента сообщения принимает глобальный объект- программа Application).

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

LabeledEdit — комбинация однострочного редактора и метки.

ColorBox — специальный вариант ComboBox для выбора одного из системных цветов.

Chart — диаграмма. Этот компонент облегчает создание специальных панелей для графического представления данных.

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

ActionMainMenuBar — полоса меню, опции которого создаются с помощью компонента ActionManager.

ActionToolBar — полоса для размещения пиктографических кнопок, создаваемых с помощью компонента ActionManager.

CustomizeDig — диалог настройки. С помощью этого компонента пользователь может по своему вкусу настроить интерфейс работающей программы.

НАЧАЛО WIN32

Страница Win32 содержит интерфейсные элементы для 32-разрядных операционных систем Windows 95/98 / NT / 2000.

TabControl — набор закладок. Каждая закладка представляет собой прямоугольное поле с надписью и / или рисунком. Выбор той или иной закладки распознается программой и используется для управления содержимым окна компонента.

Приложение Палитра компонентов

PageControl — набор панелей с закладками. Каждая панель может содержать свой набор интерфейсных элементов и выбирается щелчком по связанной с ней закладке.

ImageList — набор рисунков. Представляет собой хранилище для нескольких рисунков одинакового размера.

RichEdit — многострочный редактор форматированного текста. В отличие от компонента Memo страницы Standard текст в компоненте RichEdit подчиняется правилам расширенного текстового формата (RTF — Rich Text Format) и может изменять такие свои характеристики, как шрифт, цвет, выравнивание и т.д.

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

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

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

HotKey — управляющая клавиша. Компонент используется для ввода управляющих клавиш, таких как F1, Alt + A, Ctrl + Shift + 1 и т.п.

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

DateTimePicker — селектор времени / даты. Этот компонент предназначен для ввода и отображения даты или времени.

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

ListView — панель пиктограмм. Организует просмотр нескольких пиктограмм и выбор нужной. Этот компонент способен располагать пиктограммы в горизонтальных или вертикальных рядах и показывать их в большом или мелком масштабе.

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

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

Приложение Палитра компонентов

ToolBar — инструментальная панель. Этот компонент служит контейнером для командных кнопок BitBtn и способен автоматически изменять их размеры и положение при удалении кнопок или при добавлении новых.

CoolBar — инструментальная панель. В отличие от ToolBar используется как контейнер для размещения стандартных интерфейсных компонентов Windows, таких как Edit, ListBox, ComdoBox и т. Д

РаgеSсrоllеr — панель прокручивается. Служит для размещения узких инструментальных панелей. При необходимости автоматически создает по краям панели стрелки прокрутки.

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

НАЧАЛО SYSTEM

На этой странице представлены компоненты, имеющие различное функциональное назначение, в том числе компоненты, поддерживающие стандартные для Windows технологии межпрограммного обмена данными OLE (Object Linking and Embedding -звьязування и внедрение объектов) и DDE (Dynamic Data Exchange

-динамическая обмен данными).

Timer — таймер. Этот компонент служит для отсчета интервалов реального

времени.

PaintBox — окно для рисования.              Создает прямоугольную область,

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

MediaPlayer — мультимедийный проигрыватель.              С помощью этого компонента можно управлять различными мультимедийными устройствами.

OleContainer — OLE-контейнер. Служит приемником внедряемых объектов.

НАЧАЛО DIALOGS

Компоненты страницы Dialogs реализуют стандартные для Windows

диалоговые окна.

OpenDialog — открыть. Реализует стандартное диалоговое окно «Открыть файл».

SaveDialog — сохранить. Реализует стандартное диалоговое окно «Сохранить файл».

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

SavePictureDialog — сохранить рисунок.              Реализует специальное окно сохранения графических файлов с возможностью предварительного просмотра рисунков.

И другие компоненты.

НАЧАЛО SAMPLES

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

Gauge — индикатор состояния. Подобный компонента ProgressBar (страница Win32), но отличается большим разнообразием форм.

Приложение Палитра компонентов

СоlоrGrиd — таблица цветов. Этот компонент предназначен для выбора основного и фонового цветов с 16-цветной палитры.

SpinButton — двойная кнопка. Дает удобный способ управления некоторой числовой величиной.

SpinEdit — редактор числа. Обеспечивает отображение и редактирование целого числа с возможностью его изменения с помощью двойной кнопки.

DirectoryOutLine — список каталогов. Отражает в иерархическом виде структуру каталогов дискового накопителя.

Calendar — календарь. Предназначен для показа и выбора дня в месяце.

НАЧАЛО ACTIVE X

Компоненты Active является «чужими» для Delphi: они создаются другими инструментальными средствами разработки программ (например, C ++ или Visual Basic) и внедряются в Delphi с помощью технологии OLE.

 

КОМПОНЕНТЫ для работы с базами ДАННЫХ

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

страница Data Access

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

Страница Data Controls

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

страница dbExpress

Компоненты представлены на этой странице, поддерживают технологию

dbExpress прямого доступа к некоторым промышленных серверов баз данных.

Присутствуют также и другие страницы: DataSnap (компоненты, реализующие взаимодействие машин в локальной сети или Интернет в типичном для БД случае, когда клиент работает с удаленными данными), BDE, ADO, InterBase, Decision Cube, QReport

 

КОМПОНЕНТЫ ДЛЯ ДОСТУПА В ИНТЕРНЕТ

страница Internet

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

страница FastNet

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

страница WebServices

Компоненты этой страницы поддерживают технологию SOAP (Simple Object Access Protocol) для создания служб Web (это программа, запускается сервером Web в ответ на клиентскую запросу).

Приложение Палитра компонентов

Присутствуют также другие страницы: Indy Clients, Indy Servers, Indy Misc. Расположенные на этих страницах компоненты в функциональном плане дублируют компоненты страницы FastNet, но имеют некоторые дополнительные возможности.

учебное издание

 

 

Краткий курс программирования в среде Delphi (для студентов заочной формы обучения специальности 7.050201 «Менеджмент организаций» специализации «Информационные системы в менеджменте»).

 

 

 

Составитель: Мирошниченко Анна Анатольевна Редактор: М.З. Алябьев

 

 

 

 

 

 

 

 

 

 

 

 

План 2004, поз.66 Подп. к печати 05.07.04. Печать на ризографе.

Заказ. №

Формат 60х84 1/16 Усл.-друк.арк.3,5 Тираж 50 экз.

Бумага офисная. Область-вид.арк.4,5. Цена договорная

61002, Харьков, ХНАГХ, ул. Революции, 12

Сектор оперативной полиграфии ИВЦ ХНАГХ

61002, Харьков, ул. Революции, 12

[Всего голосов: 3    Средний: 5/5]

Читать  Тема 1 Паскаль: Формализация и алгоритмизация вычислительных процессов