Delphi ??????????? ??????? ????????? ??????? by 6f6g5Yt

VIEWS: 0 PAGES: 77

									                ФЕДЕРАЛЬНОЕ АГЕНТСТВО ПО ОБРАЗОВАНИЮ РФ

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




                  Бийский технологический институт (филиал)




               Г.И. Севодина, В.Д. Лисица, В.В. Царегородцева




             ПРОГРАММИРОВАНИЕ В СРЕДЕ DELPHI


 Лабораторный практикум по информатике для студентов инженерных и экономических
                    специальностей дневной формы обучения




                                   Бийск 2006
    УДК 681.3.06
    ББК 32.973-01



     Севодина, Г.И. Программирование в среде Delphi: лабораторный практикум по информатике для
студентов инженерных и экономических специальностей дневной формы обучения / Г.И. Севодина,
В.Д. Лисица, В.В. Царегородцева.



    Алт. гос. тех. ун-т, БТИ.  Бийск.
    Изд-во Алт. гос. тех. ун-та, 2006.  77 с.



      В лабораторном практикуме, состоящем из семи разделов, приводятся описание элементов
визуальной среды программирования Delphi, начальные сведения о языке программирования Object Pascal
и некоторые приемы технологии программирования. Многочисленные примеры к каждой теме призваны
облегчить понимание материала и использовать аналогичные приемы в разработке собственных
приложений. В конце каждой темы раздела приводится набор индивидуальных заданий для
самостоятельного выполнения. Лабораторный практикум предназначен для студентов инженерных и
экономических специальностей, изучающих программирование в рамках курса «Информатика».




                                                        Рассмотрен и одобрен на заседании
                                                        кафедры информатики и вычислительной
                                                        математики.
                                                        Протокол №45 от 3.02.2006 г.




    Рецензент: к.ф.-м.н. Чупин Н.А. (БГПУ им. В.М. Шукшина, г. Бийск)




                                                    Севодина Г.И., Лисица В.Д., Царегородцева В.В., 2006
                                                                                     БТИ АлтГТУ, 2006




2
                                       СОДЕРЖАНИЕ

Предисловие__________________________________________________________________________         4
Введение_____________________________________________________________________________         5
1 СРЕДА DELPHI. ПЕРВЫЙ ПРОЕКТ__________________________________________________               6
  1.1 Знакомство со средой Delphi________________________________________________________     6
  1.2 Лабораторная работа №1. Создание первого проекта____________________________________    8
  1.3 Некоторые итоги__________________________________________________________________      23
2 ОСНОВЫ ЯЗЫКА ПРОГРАММИРОВАНИЯ DELPHI. ПРОГРАММИРОВАНИЕ
ЛИНЕЙНЫХ ВЫЧИСЛИТЕЛЬНЫХ ПРОЦЕССОВ______________________________________                      24
  2.1 Тип данных______________________________________________________________________       24
  2.2 Переменная______________________________________________________________________       25
  2.2 Константы_______________________________________________________________________       25
  2.4 Стандартные функции_____________________________________________________________       26
  2.5 Использование функций____________________________________________________________      27
  2.6 Оператор присваивания____________________________________________________________      28
  2.7 Ввод данных______________________________________________________________________      28
  2.8 Вывод результатов________________________________________________________________      28
  2.9 Процедуры и функции_____________________________________________________________       29
  2.10 Запись операторов программы______________________________________________________     31
  2.11 Стиль программирования__________________________________________________________      31
  2.12 Лабораторная работа №2. Программирование линейных алгоритмов_____________________     32
  2.13 Выполнение индивидуального задания______________________________________________      35
3 ИСПОЛЬЗОВАНИЕ КОМПОНЕНТОВ ОРГАНИЗАЦИИ ЕРЕКЛЮЧЕНИЙ.
ПРОГРАММИРОВАНИЕ РАЗВЕТВЛЯЮЩИХСЯ АЛГОРИТМОВ________________________                          36
  3.1 Кнопки-переключатели в Delphi_____________________________________________________     36
  3.2 Разветвляющиеся алгоритмы________________________________________________________      36
  3.3 Лабораторная работа №3. Программирование разветвляющихся алгоритмов________________    40
  3.4 Индивидуальные задания___________________________________________________________      46
4 ИСПОЛЬЗОВАНИЕ СРЕДСТВ ОТЛАДКИ ПРОГРАММ В DELPHI.
ПРОГРАММИРОВАНИЕ ЦИКЛИЧЕСКИХ АЛГОРИТМОВ______________________________                        48
  4.1 Отладка программы________________________________________________________________      48
  4.2 Циклы___________________________________________________________________________       48
  4.3 Лабораторная работа №4. Программирование циклических алгоритмов____________________    50
  4.4. Индивидуальные задания__________________________________________________________      53
5 ИСПОЛЬЗОВАНИЕ КОМПОНЕНТА STRINGGRID. МАССИВЫ________________________                       55
  5.1 Объявление массива_______________________________________________________________      55
  5.2 Операции с массивами_____________________________________________________________      55
  5.3 Многомерные массивы_____________________________________________________________       56
  5.4 Лабораторная работа №5. Программирование матричных операций_______________________     58
  5.5 Индивидуальные задания___________________________________________________________      62
6 ТИПОВЫЕ ОПЕРАЦИИ С МАССИВАМИ_____________________________________________                  64
  6.1 Вычисление суммы, произведения элементов массива, минимального
и заданного значения___________________________________________________________________      64
  6.2 Лабораторная работа №6. Программирование типовых операций с матрицами______________    64
  6.3 Индивидуальные задания___________________________________________________________      66
7 СИМВОЛЫ И СТРОКИ. КОМПОНЕНТ PANEL_______________________________________                   67
  7.1 Символы_________________________________________________________________________       67
  7.2 Строки__________________________________________________________________________       67
  7.3 Операции со строками_____________________________________________________________      68
  7.4 Лабораторная работа №7. Работа с символьными и строковыми данными__________________    70
  7.5 Индивидуальные задания___________________________________________________________      74
Литература____________________________________________________________________________       76




                                                                                             3
                                             ПРЕДИСЛОВИЕ

     Среди пользователей персональных компьютеров в настоящее время наиболее популярно семейство
операционных систем Windows и, естественно желание программировать в средах, работающих «под
Windows».
     Бытует мнение, что лучшим языком для изучения и освоения программирования является Паскаль, а
лучшей в мире системой программирования для MS-DOS  Turbo Pascal.
     Однако бурное развитие вычислительной техники, потребность в эффективных средствах разработки
программного обеспечения привели к появлению новых систем программирования, ориентированных на
так называемую «быструю разработку», среди которых можно выделить Borland Delphi и Microsoft Visual
Basic. В основе систем быстрой разработки (RAD-систем, Rapid Application Development  среда быстрой
разработки      приложений)   лежит     технология    визуального     проектирования     и   событийного
программирования, суть которой заключается в том, что среда разработки берет на себя большую часть
рутинной работы, оставляя программисту работу по конструированию диалоговых окон и функций
обработки событий. При использовании RAD-систем производительность программиста резко возрастает.
     Delphi продолжила серию Паскаль-ориентированных средств программирования. Корпорация
Borland в 1995 году выпустила первую версию Delphi, а затем, с интервалом в один год,  еще четыре
версии: 2, 3, 4 и 5. В 2001 году появилась версия 6. Наконец, в 2002 г. выпускается версия 7. Язык Delphi –
строго типизированный объектно-ориентированный язык, в основе которого лежит Object Pascal.
     Для      разработки   приложений    в   Delphi    знание   концепции     объектно-ориентированного
программирования не является обязательным, т.к. визуальная среда Delphi предоставляет все средства
разработки компонентов и берет на себя многие рутинные аспекты программирования. Однако знание
языка Object Pascal является непременным условием для любого программиста, работающего в этой среде.
     Объекты в Delphi – это элементы, из которых строится приложение: форма, рамка, кнопка, метка и
др. Объектом является и включаемый визуальный компонент (например, кнопка) в том виде, как он
представлен во время помещения его на форму и во время выполнения программы. Объекты
изображаются на экране до выполнения самой программы. Поэтому программирование в Delphi –
визуальное.




4
                                             ВВЕДЕНИЕ

     В настоящем лабораторном практикуме ставятся цели: познакомить студентов со средой визуального
программирования Delphi, дать сведения о начальном курсе программирования на языке Object Pascal,
научить разрабатывать собственные простые приложения. Освоив некоторые основные приемы работы в
Delphi, пользователи смогут продолжить самостоятельное углубленное изучение и применение концепции
объектно-ориентированного программирования с помощью специальной литературы.
     В настоящем лабораторном практикуме применяется принцип соблюдения баланса учебного
материала, посвященного языку и методам программирования, а также среде разработки программ. Для
достижения быстрого результата (создания собственного приложения) многие понятия даются на уровне
определений. Каждая новая тема сопровождается примерами разработки приложений, содержащих
разнообразные компоненты.
     Материал практикума состоит из семи разделов. В конце каждого раздела приводится набор
индивидуальных заданий по нарастающей степени сложности. Степень сложности задания студент может
выбрать для себя сам. Работа по каждой теме включает три этапа:
     o чтение ознакомительного материала;
     o изучение приведенных примеров и воспроизведение их в своем проекте (фронтальная работа);
     o выполнение индивидуального задания.
     Результатом успешного изучения темы является создание работающего приложения на основе
индивидуального задания.




                                                                                                  5
                              1 СРЕДА DELPHI. ПЕРВЫЙ ПРОЕКТ

    1.1 Знакомство со средой Delphi

     Запускается Delphi обычным образом, т. е. выбором из меню Borland Delphi 7 команды Delphi 7
(рисунок 1.1).




                                      Рисунок 1.1 – Запуск Delphi

     Вид экрана после запуска Delphi несколько необычен (рисунок 1.2). Вместо одного окна на экране
появляются пять:
      главное окно Delphi 7;
      окно стартовой формы Form 1;
      окно редактора свойств объектов Object Inspector;
      окно просмотра списка объектов Object TreeView;
      окно редактора кода Unitl.pas.
     Окно редактора кода почти полностью закрыто окном стартовой формы.




                           Рисунок 1.2 – Вид экрана после запуска Delphi

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

6
            Панель инструментов        Страница Standard          Кнопка Memo
                   Debug              палитры компонентов




 Панель инструментов                 Кнопка       Кнопка          Кнопка       Кнопка      Кнопка
        View                          Label        Edit           Button      CheckBox   TRadioGroup


                                     Рисунок 1.3 – Главное окно

     Окно Object Inspector (рисунок 1.4)  окно редактора свойств объектов предназначено для
редактирования значений свойств объектов. В терминологии визуального проектирования объекты  это
элементы, из которых строится приложение: диалоговые окна и элементы управления (поля ввода и
вывода, командные кнопки, переключатели и др.). Свойства объекта  это характеристики,
определяющие вид, положение и поведение объекта. Например, свойства Width и Height задают размер
(ширину и высоту) формы, свойства Tор и Left  положение формы на экране, свойство Caption  текст
заголовка.




                        Рисунок 1.4 – Вкладка Properties испектора объектов




                                  Рисунок 1.5 – Окно редактора кода


                                                                                                 7
     В окне редактора кода (рисунок 1.5), которое можно увидеть, отодвинув в сторону окно формы,
следует набирать текст программы. В начале работы над новым проектом это окно редактора кода
содержит сформированный Delphi шаблон программы.

    1.2 Лабораторная работа №1. Создание первого проекта

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

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




                      Рисунок 1.6 – Окно программы вычисления скорости бега

     Для начала работы над новой программой запустите Delphi, выберите в меню File (Файл) команду
New | Application (Создать | Приложение).

    1.2.1 Форма

     Работа над новым проектом (так в Delphi называется разрабатываемое приложение) начинается с
создания стартовой формы.
     Стартовая форма создается путем изменения значений свойств формы Form1, задаваемых по
умолчанию, и добавления к форме необходимых компонентов (полей ввода и вывода текста, командных
кнопок и т.п.).
     Свойства формы (таблица 1.1) определяют ее внешний вид: размер, положение на экране, текст
заголовка, вид рамки.
     Для просмотра и изменения значений свойств формы и ее компонентов используется окно Object
Inspector. В верхней части окна Object Inspector указано имя объекта, значения свойств которого
отображается в данный момент. В левой колонке вкладки Properties (Свойства) перечислены свойства
объекта, а в правой  указаны их значения.
     При создании формы следует изменить значение свойства Сaption (Заголовок). В нашем примере
надо заменить текст Form1 на «Скорость бега». Чтобы это сделать, нужно в окне Object Inspector
щелкнуть мышью на строке Caption и ввести текст «Скорость бега» (рисунок 1.7).
     Аналогичным образом можно установить значения свойств Height и Width. Размер формы и ее
положение на экране, а также размер других элементов управления и их положение на поверхности
формы задают в пикселах, т. е. точках экрана. Свойствам Height и Width надо присвоить значения 250 и
330 соответственно.
     Размер формы, как и любого другого окна, можно изменить захватом и перемещением (с помощью
мыши) границы. По окончании перемещения границ автоматически изменятся значения свойств Height и
Width. Они будут соответствовать установленному размеру формы.




8
Таблица 1.1 – Свойства формы

             Свойство                                      Описание
    Name                    Имя формы. В программе имя формы используется для управления
                            формой и доступа к компонентам формы
    Caption                 Текст заголовка
    Width                   Ширина формы
    Height                  Высота формы
    Top                     Расстояние от верхней границы формы до верхней границы экрана
    Left                    Расстояние от левой границы формы до левой границы экрана
    BorderStyle             Вид границы. Граница может быть обычной (bsSizeable), тонкой
                            (bsSingle) или отсутствовать (bsNone). Если у окна обычная граница, то
                            во время работы программы пользователь может при помощи мыши
                            изменить размер окна. Изменить размер окна с тонкой границей нельзя.
                            Если граница отсутствует, то на экран во время работы программы
                            будет выведено окно без заголовка. Положение и размер такого окна во
                            время работы программы изменить нельзя

    BorderIcons             Кнопки управления окном. Значение свойства определяет, какие кнопки
                            управления окном будут доступны пользователю во время работы
                            программы. Значение свойства задается путем присвоения значений
                            уточняющим свойствам biSystemMenu, biMinimaze, biMaximaze и biHelp.
                            Свойство biSystemMenu определяет доступность кнопки Свернуть и
                            кнопки системного меню, biMinimaze  кнопки Свернуть, biMaximaze 
                            кнопки Развернуть, biHelp  кнопки вывода справки
    Icon                    Значок в заголовке диалогового окна, обозначающий кнопку вывода
                            системного меню
    Color                   Цвет фона. Цвет можно задать, указав название цвета или привязку к
                            текущей цветовой схеме операционной системы. Во втором случае цвет
                            определяется текущей цветовой схемой, выбранным компонентом
                            привязки и меняется при изменении цветовой схемы операционной
                            системы
    Font                    Шрифт. Шрифт, используемый «по умолчанию» компонентами,
                            находящимися на поверхности формы. Изменение свойства Font формы
                            приводит к автоматическому изменению свойства Font компонента,
                            располагающегося на поверхности формы. То есть компоненты
                            наследуют свойство Font от формы (имеется возможность запретить
                            наследование)




                    Рисунок 1.7 – Установка значения свойства путем ввода значения

                                                                                                     9
     При выборе некоторых свойств, например Borderstyle, справа от текущего значения свойства
появляется значок раскрывающегося списка. Очевидно, что значение таких свойств можно задать путем
выбора из списка (рисунок 1.8).
     Некоторые свойства являются сложными, т. е. их значение определяется совокупностью значений
других (уточняющих) свойств. Перед именами сложных свойств стоит значок "+", при щелчке на котором
раскрывается список уточняющих свойств (рисунок 1.9). Например, свойство BorderIcons определяет,
какие кнопки управления окном будут доступны во время работы программы. Так, если свойству
biMaximize присвоить значение False, то во время работы программы кнопки Развернуть в заголовке окна
не будет.




                   Рисунок 1.8 – Установка значения свойства путем выбора из списка




           Рисунок 1.9 – Раскрытый список уточняющих свойств сложного свойства BorderIcons

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

Таблица 1.2 – Значения свойств стартовой формы

           Свойство              Значение
 Caption                      Скорость бега
 Height                       250
 Width                        330
 BorderStyle                  bsSingle
 BorderIcons.biMinimize       False
 BorderIcons.biMaximize       False
 Font. Size                   10


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




                       Рисунок 1.10 – Форма после установки значений свойств


    1.2.2 Компоненты

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




         Рисунок 1.11 – Вкладка Standard содержит наиболее часто используемые компоненты

     Размер компонента можно отрегулировать мышью, используя стандартный приём работы с
графическими объектами в Windows.
     Положение компонента можно также менять, перемещая объект с одного места формы в другое. Во
время перемещения отображаются текущие значения координат левого верхнего угла компонента
(значения свойств Left и Тор) в окне Object Inspector.
     Свойства компонента так же, как и свойства формы, можно изменять при помощи Object Inspector.
     Каждому компоненту Delphi присваивает имя, которое состоит из названия компонента и его
порядкового номера. Например, если к форме добавить два компонента Edit, то их имена будут Edit1 и
Edit2. Программист путем изменения значения свойства Name может изменить имя компонента.
В простых программах имена компонентов, как правило, не изменяют.
     На рисунке 1.12 приведен вид формы после добавления двух компонентов Edit – полей
редактирования, предназначенных для ввода исходных данных. Свойства выделенного компонента
(щелчок левой кнопки мыши) отображаются в окне Object Inspector. Выбрать имя компонента можно
также в окне Object TreeView или из находящегося в верхней части окна Object Inspector
раскрывающегося списка объектов. В таблице 1.3 перечислены свойства компонента Edit.




                                                                                                  11
                       Рисунок 1.12 – Форма после добавления компонентов Edit

Таблица 1.3 – Свойства компонента Edit (поле ввода-редактирования)
    Свойство                                        Описание
 Name              Имя компонента. Используется в программе для доступа к компоненту и его
                   свойствам, в частности  для доступа к тексту, введенному в поле
                   редактирования
 Text              Текст, находящийся в поле ввода и редактирования
 Left              Расстояние от левой границы компонента до левой границы формы
 Top               Расстояние от верхней границы компонента до верхней границы формы
 Height            Высота поля
 Width             Ширина поля
 Font              Шрифт, используемый для отображения вводимого текста
 ParentFont        Признак наследования компонентом характеристик шрифта формы, на
                   которой находится компонент. Если значение свойства равно True, то при
                   изменении свойства Font формы автоматически меняется значение свойства
                   Font компонента


     Помимо полей редактирования в окне программы должна находиться краткая информация о
программе и назначении полей ввода. Для этого используется компонент Label  метка. Значок
компонента Label находится на вкладке Standard и помечен буквой «А». Добавляется компонент Label в
форму точно так же, как и поле редактирования.
     Добавим в форму разрабатываемого приложения четыре компонента Label. Первое поле
предназначено для вывода информационного сообщения, второе и третье  для вывода информации о
назначении полей ввода, четвертое поле  для вывода результата расчета (скорости).
     Свойства компонента Label перечислены в таблице 1.4.
     Следует обратить внимание на свойства Autosize и Wordwrap. Эти свойства нужно использовать,
если поле вывода должно содержать несколько строк текста. После добавления к форме компонента Label
значение свойства Autosize равно True, т. е. размер поля определяется автоматически в процессе
изменения значения свойства Сaption. Если вы хотите, чтобы находящийся в поле вывода текст занимал
несколько строк, то надо присвоить свойству Autosize значение False, свойству Wordwrap  значение True.
Затем нужно задать требуемый размер поля. Только после этого можно ввести в свойство Caption текст,
который должен быть выведен в поле.
     После добавления полей вывода текста (четырех компонентов Label) и установки значений их
свойств в соответствии с таблицей 1.5 форма программы принимает вид, приведенный на рисунке 1.13.
     Последнее, что надо сделать на этапе создания формы  добавить в форму две командные кнопки:
Вычислить и Завершить. Назначение этих кнопок очевидно.
     Командная кнопка (компонент Button) добавляется в форму точно так же, как и другие компоненты.
Значок компонента Button находится на вкладке Standard и помечен как «ОК». Свойства компонента
приведены в таблице 1.6.




12
Таблица 1.4 – Свойства компонента Label (поле вывода текста)
   Свойство                                         Описание
  Name          Имя компонента. Используется в программе для доступа к компоненту и его
                свойствам
  Caption       Отображаемый текст
  Font          Шрифт, используемый для отображения текста
  ParentFont    Признак наследования компонентом характеристик шрифта формы, на которой
                находится компонент. Если значение свойства равно True, текст выводится
                шрифтом, установленным для формы
  AutoSize      Признак того, что размер поля определяется его содержимым
  Left          Расстояние от левой границы поля вывода до левой границы формы
  Top           Расстояние от верхней границы поля вывода до верхней границы формы
  Height        Высота поля вывода
  Width         Ширина поля вывода
  Wordwrap      Признак того, что слова, которые не помещаются в текущей строке, автоматически
                переносятся на следующую строку




                   Рисунок 1.13 – Вид формы после добавления полей вывода текста

Таблица 1.5 – Значения свойств компонентов Label1, Label2, Label3 и Label4
    Компонент             Свойство                    Значение
 Label1                 AutoSize            False
                        Wordwrap            True
                        Caption             Программа вычислит скорость,
                                            с которой спортсмен пробежит
                                            дистанцию
                        Top                 8
                        Left                8
                        Height              33
                        Width               209
 Label2                 Top                 56
                        Left                8
                        Caption             Дистанция (метров)
 Label3                 Top                 88
                        Left                8
                        Caption             Время (минуты, секунды)
 Label4                 AutoSize            False
                        Wordwrap            True
                        Top                 120
                        Left                8
                        Height              41
                        Width               273



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

Таблица 1.6 – Свойства компонента Button (командная кнопка)
  Свойство                                            Описание
 Name              Имя компонента. Используется в программе для доступа к компоненту и его
                   свойствам
 Caption           Текст на кнопке
 Enabled           Признак доступности кнопки. Кнопка доступна, если значение свойства равно
                   True, и недоступна, если значение свойства равно False
 Left              Расстояние от левой границы кнопки до левой границы формы
 Top               Расстояние от верхней границы кнопки до верхней границы формы
 Height            Высота кнопки
 Width             Ширина кнопки

Таблица 1.7 – Значения свойств компонентов Button1 и Button2
                             Компонент
     Свойство
                        Button1      Button2
 Caption             Вычислить     Завершить
 Тор                 176           176
 Left                16            112
 Height              25            25
 Width               75            75


     Окончательный вид формы разрабатываемого приложения должен иметь вид примерно, как на
рисунке 1.13.
     Завершив работу по созданию формы приложения, можно приступить к написанию текста
программы (кода). Но перед этим обсудим очень важные при программировании в Windows понятия:
      событие;
      процедура обработки события.

     1.2.3 Событие и процедура обработки события

     Вид созданной формы подсказывает, как работает приложение. Очевидно, что пользователь должен
ввести в поля редактирования исходные данные и щелкнуть мышью на кнопке Вычислить. Щелчок на
изображении командной кнопки  это пример того, что в Windows называется событием.
     Событие (Event)  это то, что происходит во время работы программы. В Delphi каждому событию
присвоено имя. Например, щелчок кнопкой мыши  это событие OnClick, двойной щелчок мышью
событие OnDblClick.
     Реакцией на событие должно быть какое-либо действие. В Delphi реакция на событие реализуется
как процедура обработки события. Таким образом, для того чтобы программа выполняла некоторую
работу в ответ на действия пользователя, программист должен написать процедуру обработки
соответствующего события. Значительную часть обработки событий берет на себя компонент. Поэтому
программист должен разрабатывать процедуру обработки события только в том случае, если реакция на
событие отличается от стандартной или не определена. Например, если по условию задачи ограничений на
символы, вводимые в поле Edit, нет, то процедуру обработки события OnKeyPress писать не надо, т. к. во
время работы программы будет использована стандартная (скрытая от программиста) процедура
обработки этого события.
     Методику создания процедур обработки событий рассмотрим на примере процедуры обработки
события OnClick для командной кнопки Вычислить.
     В таблице 1.8 приводятся некоторые события Windows.
     Выделим нужный компонент и выберем вкладку Events (События).
     В левой колонке вкладки Events (рисунок 1.14) перечислены имена событий, которые может
воспринимать выбранный компонент (объект). Если для события определена (написана) процедура
обработки события, то в правой колонке рядом с именем события выводится имя этой процедуры.




14
Таблица 1.8 – Некоторые события Windows

       Событие                                         Происходит
 OnClick               При щелчке кнопкой мыши

 OnDblClick            При двойном щелчке кнопкой мыши
 OnMouseDown           При нажатии кнопки мыши
 OnMouseUp             При отпускании кнопки мыши
 OnMouseMove           При перемещении мыши
 OnKeyPress            При нажатии клавиши клавиатуры
 OnKeyDown             При нажатии клавиши клавиатуры. События OnKeyDown и OnKeyPress  это
                       чередующиеся, повторяющиеся события, которые происходят до тех пор, пока
                       не будет отпущена удерживаемая клавиша (в этот момент происходит событие
                       OnKeyUp)
 OnKeyUp               При отпускании нажатой клавиши клавиатуры
 OnCreate              При создании объекта (формы, элемента управления). Процедура обработки
                       этого события обычно используется для инициализации переменных,
                       выполнения подготовительных действий
 OnPaint               При появлении окна на экране в начале работы программы, после появления
                       части окна, которая, например, была закрыта другим окном, и в других случаях

 OnEnter               При получении элементом управления фокуса
 OnExit                При потере элементом управления фокуса




                        Рисунок 1.14 – Вкладка Events окна Object Inspector

     Для создания функции обработки события нужно сделать двойной щелчок мышью в поле имени
процедуры обработки соответствующего события. В результате этого откроется окно редактора кода, в
которое будет добавлен шаблон процедуры обработки события, а в окне Object Inspector рядом с именем
события появится имя функции его обработки (рисунок 1.15).
     Delphi присваивает функции обработки события имя, которое состоит из двух частей. Первая часть
имени идентифицирует форму, содержащую объект (компонент). Вторая часть имени идентифицирует
сам объект и событие. В нашем примере имя формы – Form1, имя командной кнопки – Button1, а имя
события – Click.




                                                                                                      15
            Рисунок 1.15 – Шаблон процедуры обработки события, сгенерированный Delphi

     В окне редактора кода между словами begin и end можно печатать инструкции (команды),
реализующие функцию обработки события.
     В листинге 1.1 приведен текст процедуры обработки события OnClick для командной кнопки
Вычислить. Обратите внимание на то, как представлена программа. Ее общий вид соответствует тому,
как она выглядит в окне редактора кода: ключевые слова выделены полужирным, комментарии (отделены
от инструкций двумя наклонными линиями)  курсивом (выделение выполняет редактор кода). Кроме
того, инструкции программы набраны с отступами в соответствии с принятыми в среде программистов
правилами хорошего стиля. Комментарии в программе можно также оформлять в фигурных скобках.

     Листинг 1.1 Процедура обработки события OnClick на кнопке Button1 (Вычислить)

// нажатие кнопки Вычислить
procedure TForm1.Button1Click(Sender: TObject);
  var
  dist: integer; // дистанция, метров (целый тип)
  t: real; // время как дробное число (вещественный тип)
  min: integer; // время, минуты
  sek: integer; // время, секунды
  v: real; // скорость
    begin
       // получить исходные данные из полей ввода
       dist:=StrToint(Edit1.Text); t:=StrToFloat(Edit2.Text);
       // предварительные преобразования из текста в числа соответствующего
       типа
       min:=Trunc(t); // кол-во минут — это целая часть числа t
       sek:=Trunc(t*100) mod 100;
       // кол-во секунд — это дробная часть числа t
       // вычисление
       v:=(dist/1000)/((min*60 + sek)/3600);
       // вывод результата
       label4.Caption:= 'Дистанция: '+ Edit1.Text + ' м' + #13 + 'Время: '
       + IntToStr(min) + ' мин ' + IntToStr(sek) + ' сек '
       + #13 +// #13 – код клавиши <Еnter>
       'Скорость: ' + FloatToStrF(v,ffFixed,4,2) + ' км/час';
    end;

     Функция Button1Сlick выполняет расчет скорости и выводит результат расчета в поле Label4.
Исходные данные вводятся из полей редактирования Edit1 и Edit2 путем обращения к свойству Text.
Свойство Text содержит строку символов, которую во время работы программы введет пользователь. Для
правильной работы программы строка должна содержать только цифры. Для преобразования строки в
числа в программе используются функции StrToInt и StrToFloat. Функция StrToInt проверяет символы
строки, переданной ей в качестве параметра (Edit1.Text  это содержимое поля Edit1), на допустимость и,
если все символы верные, возвращает соответствующее число. Это число записывается в переменную dist.



16
Аналогичным образом работает функция StrToFloat, которая возвращает дробное число, соответствующее
содержимому поля Edit2. Это число записывается в переменную t.
      После того как исходные данные будут помещены в переменные dist и t, выполняются действия по
определению количества минут и секунд, содержащихся в переменной t. Первоначально с использованием
функции Trunc, которая «отбрасывает» дробную часть числа, выделяется целая часть переменной t  это
количество минут. Значением выражения Trunc(t*100) mod 100 является количество секунд. Вычисляется
это выражение так. Сначала число t умножается на 100. Полученное значение передается функции Trunc,
которая возвращает целую часть результата умножения t на 100. Полученное таким образом число делится
на 100. Результат деления – это остаток от деления.
      После того как все данные готовы, выполняется расчет. Так как скорость должна быть выражена в
км/ч, то значения дистанции и времени, выраженные в метрах и минутах, преобразуются в километры и
часы.
      Вычисленное значение скорости выводится в поле Label4 путем присваивания значения свойству
Caption. Для преобразования чисел в строки используются функции обратного преобразования IntToStr и
FloatToStr.
      В результате нажатия кнопки Завершить программа должна завершить работу. Чтобы это
произошло, надо закрыть, убрать с экрана, главное окно программы. Делается это при помощи метода
close. Процедура обработки события Onclick для кнопки Завершить приведена в листинге 1.2.

     Листинг 1.2 Процедура обработки события Onclick на кнопке Button2 (Завершить)

     // нажатие кнопки Завершить
     procedure Tform1.Button2Click(Sender: Tobject);
        begin
           Form1.Close; // закрыть главное окно программы
        end;

     1.2.4 Редактор кода

     В процессе разработки программы часто возникает необходимость переключения между окном
редактора кода и окном формы. Сделать это можно при помощи командной кнопки Toglle Form/Unit,
находящейся на панели инструментов View (см. рисунок 1.3), или нажав клавишу <F12>. На этой же
панели инструментов находятся командные кнопки View Unit и View Form, используя которые можно
выбрать нужный модуль или форму в случае, если проект состоит из нескольких модулей или форм.

     1.2.5 Система подсказок

     В процессе набора текста программы редактор кода выводит справочную информацию о параметрах
процедур и функций, о свойствах и методах объектов.
     Например, если в окне редактора кода набрать procedure и открывающую скобку, то на экране
появится окно подсказки, в котором будут перечислены параметры процедуры с указанием их типа. Один
из параметров выделен полужирным шрифтом. Так редактор подсказывает программисту, какой параметр
он должен вводить. После набора параметра и запятой в окне подсказки будет выделен следующий
параметр. И так до тех пор, пока не будут указаны все параметры.
     Для объектов редактор кода выводит список свойств и методов. Как только программист наберет имя
объекта (компонента) и точку, так сразу на экране появляется окно подсказки  список свойств и методов
этого объекта. Перейти к нужному элементу списка можно при помощи клавиш перемещения курсора или
набрав на клавиатуре несколько первых букв имени нужного свойства или метода. После того как будет
выбран нужный элемент списка и нажата клавиша <Enter>, название выбранного свойства или метода
будут вставлены в текст программы.
     Система подсказок существенно облегчает процесс подготовки текста программы, избавляет от
рутины. Кроме того, если во время набора программы подсказка не появилась, это значит, что
программист допустил ошибку: скорее всего, неверно набрал имя процедуры или функции.

     1.2.6 Навигатор кода

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

                                                                                                   17
     Окно навигатора кода можно закрыть обычным образом. Если окно навигатора кода недоступно, то
для того, чтобы оно появилось на экране, нужно из меню View выбрать команду Code Explorer.




                                Рисунок 1.16 – Окно редактора кода

     1.2.7 Структура проекта

     Проект Delphi представляет собой набор взаимосвязанных форм и модулей, образующих
приложение. Модули проекта используют другие модули, определенные их оператором uses. Главной
частью приложения является файл проекта, с которого начинается выполнение программы. Это
программный код на языке Object Pascal. Он формируется Delphi автоматически и содержит ссылки на
формы проекта, инициализирует проект. Файл проекта имеет расширение dpr. Для того чтобы увидеть
текст файла проекта, нужно из меню Project выбрать команду View Source.
     В листинге 1.3 приведен текст файла проекта вычисления скорости бега.

     Листинг 1.3 Главная часть приложения – файл проекта

     program VelRun;
        uses
        Forms, velosity in 'velosity.pas' {Form1};
        {$R *.res}
           begin
              Application.Initialize;
              Application.CreateForm(TForm1, Form1);
              Application.Run;
           end.

     Начинается главный модуль словом program, за которым следует имя программы, совпадающее с
именем проекта. Имя проекта задается в момент сохранения проекта и оно определяет имя создаваемого
компилятором исполняемого файла программы. Далее за словом uses следуют имена используемых
модулей: библиотечного модуля Forms и модуля формы velosity.pas.
     Строка {$R *.RES}  директива компилятору подключить файл ресурсов. Файл ресурсов содержит
ресурсы приложения: пиктограммы, курсоры, битовые образы и др. Звездочка показывает, что имя файла
ресурсов такое же, как и у файла проекта, но с расширением res.
     Исполняемая часть главного модуля находится между инструкциями begin и end. Инструкции
исполняемой части обеспечивают инициализацию приложения и вывод на экран стартового окна.
     Помимо главного модуля, каждая программа включает в себя еще, как минимум, один модуль
формы, который содержит описание стартовой формы приложения и поддерживающих ее работу
процедур. В Delphi каждой форме соответствует свой модуль.
     В листинге 1.4 приведен текст модуля программы вычисления скорости бега.




18
    Листинг 1.4 Модуль программы «Скорость бега»

    unit velosity;
    interface
    uses
      Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls,
      Forms, Dialogs, StdCtrls;
    type
         TForm1 = class(TForm)
         Edit1: TEdit;
         Edit2: TEdit;
         Label1: TLabel;
         Label2: TLabel;
         Label3: TLabel;
         Label4: TLabel;
         Button1: TButton;
         Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
       private
         {Private declarations}
       public
           {Public declarations}
    end;
      var
      Form1: TForm1;
    implementation
    {$R *.dfm}
    procedure TForm1.Button1Click(Sender: TObject);
      var
          dist: integer; // дистанция, метров
          t: real; // время как дробное число- вещественный тип
          min: integer; // время, минуты
          sek: integer; // время, секунды
          v: real; // скорость
    begin
          // получить исходные данные из полей ввода
          dist:=StrToint(Edit1.Text); t:=StrToFloat(Edit2.Text);
          // предварительные преобразования – из текста в числа
          min:=Trunc(t); // кол-во минут — это целая часть числа t
          sek:=Trunc(t*100) mod 100; // кол-во секунд — это дробная часть
                                        числа t
          v:=(dist/1000)/((min*60 + sek)/3600);
          // вывод результата
          label4.Caption:= 'Дистанция: '+ Edit1.Text + ' м' + #13 + 'Время: '
          + IntToStr(min)
          + ' мин ' + IntToStr(sek) + ' сек ' + #13 +
          'Скорость: ' + FloatToStrF(v,ffFixed,4,2) + ' км/час';
    end;
    // нажатие кнопки Завершить
    procedure TForm1.Button2Click(Sender: TObject);
       begin
            Form1.Close; //закрыть главное окно программы
       end;
    end.

     Начинается модуль словом unit, за которым следует имя модуля. Именно это имя упоминается в
списке используемых модулей в инструкции uses файла проекта, текст которого приведен в листинге 1.3.
Модуль состоит из следующих секций:
      интерфейса;
      реализации;
      инициализации.


                                                                                                 19
     Секция интерфейса (начинается словом interface) сообщает компилятору, какая часть модуля
является доступной для других модулей программы. В этом разделе перечислены (после слова uses)
библиотечные модули, используемые данным модулем. Также здесь находится сформированное Delphi
описание формы, которое следует за словом type.
     Секция реализации открывается словом implementation и содержит объявления локальных
переменных, процедур и функций, поддерживающих работу формы. Начинается секция реализации
директивой {$R *.DFM}, указывающей компилятору, что в процессе генерации выполняемого файла надо
использовать описание формы. Описание формы находится в файле с расширением .dfm, имя которого
совпадает с именем модуля. Файл описания формы генерируется средой Delphi на основе внешнего вида
формы. За директивой ($R *.DFM} следуют процедуры обработки событий для формы и ее компонентов.
Сюда же программист может поместить другие процедуры и функции.
     Инструкции секции инициализации располагаются после секции реализации (описания всех
процедур и функций) между begin и end. Если раздел инициализации не содержит инструкций (как в
приведенном примере), то слово begin не указывается.
     Следует отметить, что значительное количество инструкций модуля формирует Delphi. Например,
Delphi, анализируя действия программиста по созданию формы, генерирует описание класса формы
(после слова type). В приведенном примере инструкции, набранные программистом, выделены фоном.
Очевидно, что Delphi выполнила значительную часть работы по составлению текста программы.

     1.2.8 Сохранение проекта

     Проект  это набор файлов, используя которые компилятор создает исполняемый файл программы
(ЕХЕ-файл). В простейшем случае проект состоит из файла описания проекта (DOF-файл), файла проекта
(DPR-файл), файла ресурсов (RES-файл), файла описания формы (DFM-файл), файла модуля формы, в
котором находится основной код приложения, в том числе функции обработки событий на компонентах
формы (PAS-файл), файл конфигурации (CFG-файл).
     Чтобы сохранить проект, нужно из меню File выбрать команду Save Project As. Если проект еще ни
разу не был сохранен, то Delphi сначала предложит сохранить модуль (содержимое окна редактора кода),
поэтому на экране появится окно Save Unit1 As. В этом окне надо выбрать папку, предназначенную для
файлов проекта, и ввести имя модуля. После нажатия кнопки Сохранить появляется следующее окно, в
котором необходимо ввести имя файла проекта.
     Обратите внимание на то, что имена файлов модуля (pas-файл) и проекта (dpr-файл) должны быть
разными. Имя генерируемого компилятором исполняемого файла совпадает с именем проекта. Поэтому
файлу проекта следует присвоить такое имя, которое, по вашему мнению, должен иметь исполняемый
файл программы, а файлу модуля  какое-либо другое имя, например, полученное путем добавления к
имени файла проекта порядкового номера модуля. В приведенном примере имя модуля  velosity, а имя
проекта – VelRun.
     Примечание – Так как проект представляет собой набор файлов, то рекомендуется для каждого
проекта создавать отдельную папку.

     1.2.9 Компиляция

     Компиляция  это процесс преобразования исходной программы в исполняемую. Процесс
компиляции состоит из двух этапов. На первом этапе выполняется проверка текста программы на
отсутствие ошибок, на втором  генерируется исполняемая программа (ехе-файл).
     После ввода текста функции обработки события и сохранения проекта можно из меню Project
выбрать команду Compile и выполнить компиляцию. Процесс и результат компиляции отражаются в
диалоговом окне Compiling (рисунок 1.17). В это окно компилятор выводит ошибки (Errors),
предупреждения (Warnings) и подсказки (Hints). Сами сообщения об ошибках, предупреждения и
подсказки отображаются в нижней части окна редактора кода (рисунок 1.18).




                                Рисунок 1.17 – Результат компиляции

20
     Примечание – Если во время компиляции окна Compiling на экране нет, то выберите из меню Tools
команду Environment options и на вкладке Preferences установите во включенное состояние
переключатель Show compiler progress.




                     Рисунок 1.18 – Сообщения компилятора об обнаруженных ошибках

     1.2.10 Ошибки

     Компилятор генерирует исполняемую программу лишь в том случае, если исходный текст не
содержит синтаксических ошибок. В большинстве случаев в только что набранной программе есть
ошибки. Программист должен их устранить.
     Чтобы перейти к фрагменту кода, который содержит ошибку, надо установить курсор в строку с
сообщением об ошибке и из контекстного меню выбрать команду Edit source.
     Процесс устранения ошибок носит итерационный характер. Обычно сначала устраняются наиболее
очевидные ошибки, например, декларируются необъявленные переменные. После очередного внесения
изменений в текст программы выполняется повторная компиляция. Следует учитывать тот факт, что
компилятор не всегда может точно локализовать ошибку. Поэтому, анализируя фрагмент программы,
который, по мнению компилятора, содержит ошибку, нужно обращать внимание не только на тот
фрагмент кода, на который компилятор установил курсор, но и на тот, который находится в предыдущей
строке.
     Если компилятор обнаружил достаточно много ошибок, то просмотрите все сообщения, устраните
сначала наиболее очевидные ошибки и выполните повторную компиляцию. Вполне вероятно, что после
этого количество ошибок значительно уменьшится. Это объясняется особенностями синтаксиса языка,
когда одна незначительная ошибка может «тащить» за собой довольно большое количество других.
     Если в программе нет синтаксических ошибок, компилятор создает исполняемый файл программы.
Имя исполняемого файла такое же, как и у файла проекта, а расширение  exe. Delphi помещает
исполняемый файл в тот же каталог, где находится файл проекта.

     1.2.11 Предупреждения и подсказки

     При обнаружении в программе неточностей, которые не являются ошибками, компилятор выводит
подсказки (Hints) и предупреждения (Warnings).
     Например, наиболее часто выводимой подсказкой является сообщение об объявленной, но не
используемой переменной: Variable ... is declared but never used in ... Действительно, зачем объявлять
переменную и не использовать ее?
     В таблице 1.9 приведены предупреждения, наиболее часто выводимые компилятором.

Таблица 1.9 – Предупреждения компилятора
                   Предупреждение                                  Вероятная причина
Variable... is declared but never used in ...     Переменная не используется
Variable . . . might not have been initialized.   В программе нет инструкции, которая присваивает
(Вероятно, используется не                        переменной начальное значение
инициализированная переменная)

                                                                                                    21
     1.2.12 Запуск программы

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

     1.2.13 Окончательная настройка приложения

     После того как программа отлажена, необходимо выполнить ее окончательную настройку, т. е.
задать название программы и выбрать значок, который будет изображать исполняемый файл приложения
в папке или на рабочем столе, а также на панели задач во время работы программы.
     Настройка приложения выполняется на вкладке Application диалогового окна Project Options
(рисунок 1.19), которое появляется в результате выбора из меню Project команды Options.
     В поле Title надо ввести название приложения. Текст, который будет введен в это поле, будет
выведен на панели задач Windows рядом со значком, изображающим работающую программу.




       Рисунок 1.19 – Используя вкладку Application, можно задать значок и название программы
     Чтобы назначить приложению значок, отличный от стандартного, нужно щелкнуть мышью на
кнопке Load Icon. Затем, используя стандартное окно просмотра папок, найти подходящий значок (значки
хранятся в файлах с расширением ico).

     1.2.14 Создание значка для приложения

     В состав Delphi входит программа Image Editor (Редактор изображений), при помощи которой
программист может создать для своего приложения уникальный значок. Запускается Image Editor
выбором соответствующей команды из меню Tools или из Windows  командой Пуск | Программы
Borland Delphi 7 | Image Editor.
     Чтобы начать работу по созданию нового значка, нужно из меню File выбрать команду New, а из
появившегося списка  опцию Icon File.
     После выбора типа создаваемого файла открывается окно Icon Properties, в котором необходимо
выбрать характеристики создаваемого значка: Size (Размер)  3232 (стандартный размер значков
Windows) и Colors (Палитра)  16 цветов. В результате нажатия кнопки ОК открывается окно Icon1.ico, в
котором можно, используя стандартные инструменты и палитру, нарисовать нужный значок.
     Процесс рисования в Image Editor практически ничем не отличается от процесса создания картинки в
обычном графическом редакторе, например, в Microsoft Paint. Однако есть одна тонкость. Первоначально
поле изображения закрашено «прозрачным» (transparent) цветом. Если значок нарисовать на этом фоне, то
при его выводе части поля изображения, закрашенные «прозрачным» цветом, примут цвет фона, на
котором будет находиться значок.
     В процессе создания картинки можно удалить (стереть) ошибочно нарисованные элементы, закрасив
их прозрачным цветом, которому на палитре соответствует левый квадрат в нижнем ряду.
     Кроме «прозрачного» цвета, в палитре есть «инверсный» цвет. Нарисованные этим цветом части
рисунка при выводе на экран окрашиваются инверсным цветом относительно цвета фона.
     Сохраняется созданный значок обычным образом, т. е. выбором из меню File команды Save.
22
    1.3 Некоторые итоги

     Сформулируем главные выводы, полученные в ходе работы с приложением.
      Процесс создания Delphi-программы разбивается на две фазы: фазу конструирования формы и
фазу кодирования.
      Конструирование формы осуществляется с помощью выбора компонентов из палитры и
размещения их на форме.
      Программист может перемещать любой размещенный на форме компонент и изменять его
размеры с помощью мыши.
      Чтобы придать компоненту нужные свойства, используется страница Properties Инспектора
объектов.
      Чтобы компонент мог откликаться на то или иное событие, программист должен создать
обработчик события и указать его имя на странице Events Инспектора объектов.
      Обработчик события оформляется в виде процедуры, имеющей составное имя. Первая часть
имени представляет собой имя класса для формы, вторая часть отделяется от первой точкой и может быть
произвольной. Если Delphi автоматически формирует заготовку для обработчика, то вторая часть имени
представляет собой объединение имени компонента и имени события без предлога On.
      Тело процедуры ограничено словами begin... end и состоит из отдельных предложений
(операторов) языка Object Pascal. В конце каждого предложения ставится точка с запятой.
      Свойства компонента могут изменяться на этапе прогона программы.




                                                                                                 23
                2 ОСНОВЫ ЯЗЫКА ПРОГРАММИРОВАНИЯ DELPHI.
         ПРОГРАММИРОВАНИЕ ЛИНЕЙНЫХ ВЫЧИСЛИТЕЛЬНЫХ ПРОЦЕССОВ

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

       2.1 Тип данных

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

       2.1.1 Целый тип

     Язык Delphi поддерживает семь целых типов данных: shortint, smallint, longint, int64, byte, word и
longword, описание некоторых приведено в таблице 2.1.

Таблица 2.1 – Целые типы
    Тип                 Диапазон                          Формат                Примеры
 shortint               -128  127                         8 битов               -5; 67; 0
 smallint            -32 768  32 767                     16 битов              -387; 4; 65
 longint,                                                                       -104; 5062
              -2 147 483 648  2 147 483 647              32 бита
 integer
 byte                     0  255                8 битов, беззнаковый           0; 3; 75; 254
 word                    0  65 535              16 битов, беззнаковый          0; 61; 56321

       2.1.2 Вещественный тип

     Язык Delphi поддерживает шесть вещественных типов: real48, single, double, extended, сomp, currency.
Типы различаются между собой диапазоном допустимых значений, количеством значащих цифр и
количеством байтов, необходимых для хранения данных в памяти компьютера (таблица 2.2).

Таблица 2.2 – Некоторые вещественные (дробные) типы
                                               Значащие
       Тип               Диапазон                                    Формат
                                                цифры
 real48            2,910  1,710
                          -39         38
                                                11  12              6 байт
 single            1,510-45  3,41038          78                 4 байта
 double,
                   5,010-324  1,710308       15  16              8 байтов
 real

       2.1.3 Символьный тип

       Язык Delphi поддерживает два символьных типа – ansichar и widechar:
        тип ansichar  это символы в кодировке ANSI, которым соответствуют числа в диапазоне от 0 до
255;
        тип widechar  это символы в кодировке Unicode, им соответствуют числа от 0 до 65 535.

     Примечание – В операционной системе MS DOS используется кодировка ASCII, а в Windows 
ANSI, буквы русского алфавита, в которых имеют разные коды.
     Object Pascal поддерживает и наиболее универсальный символьный тип – char, который
эквивалентен ansichar.

       2.1.4 Строковый тип

      Язык Delphi поддерживает три строковых типа – shortstring, longstring, widestring:
       тип shortstring представляет собой статически размещаемые в памяти компьютера строки длиной
от 0 до 255 символов;
       тип longstring представляет собой динамически размещаемые в памяти строки, длина которых
ограничена только объемом свободной памяти;

24
      тип widestring представляет собой динамически размещаемые в памяти строки, длина которых
ограничена только объемом свободной памяти. Каждый символ строки типа widestring является Unicode-
символом.
     В языке Delphi для обозначения строкового типа допускается использование идентификатора string.
Тип string эквивалентен типу shortstring.

    2.1.5 Логический тип

     Логическая величина может принимать одно из двух значений True (истина) или False (ложь).
В языке Delphi логические величины относят к типу boolean.

    2.2 Переменная

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

    2.2.1 Именование переменных

     Желательно, чтобы имя переменной было логически связано с ее назначением. Например,
переменным, предназначенным для хранения коэффициентов и корней квадратного уравнения, которое в
общем виде традиционно записывают: ax2 +bx +c =0, вполне логично присвоить имена а, b, с, x1 и х2.
     В языке Delphi каждая переменная перед использованием должна быть объявлена. С помощью
объявления устанавливается не только факт существования переменной, но и задается ее тип, чем
указывается и диапазон допустимых значений.
     В общем виде инструкция объявления переменной выглядит так:
     имя: тип;
     где:
      имя  имя переменной;
      тип  тип данных, для хранения которых предназначена переменная.
     Например:
     а: real; b: real; i: integer; L,Fl: boolean; St: string; S: char;

     В приведенных примерах объявлены две переменные типа real, одна переменная типа integer, две
переменные типа boolean, по одной переменной типа string и char.
     Если в программе имеется несколько переменных, относящихся к одному типу, то имена этих
переменных можно перечислить в одной строке через запятую, а тип переменных указать после имени
последней переменной через двоеточие, например: а,b,с: real; x1,x2: real;

    2.3 Константы

     В языке Delphi существует два вида констант: обычные и именованные.
     Обычная константа  это целое или дробное число, строка символов или отдельный символ,
логическое значение.

    2.3.1 Числовые константы

     В тексте программы числовые константы записываются обычным образом, т. е. так же, как числа,
например, при решении математических задач. При записи дробных чисел для разделения целой и
дробных частей используется точка. Если константа отрицательная, то непосредственно перед первой
цифрой ставится знак «минус».
     Примеры числовых констант: 123 0.0 654.76 -524.03 10
     Дробные константы могут изображаться в виде числа с плавающей точкой. Представление в виде
числа с плавающей точкой основано на том, что любое число может быть записано в алгебраической
форме как произведение числа, меньшего 10, которое называется мантиссой, и степени десятки,
именуемой порядком.


                                                                                                 25
    В таблице 2.3 приведены примеры чисел, записанных в обычной форме, в алгебраической форме и
форме с плавающей точкой.
Таблица 2.3 – Примеры записи дробных чисел
      Число          Алгебраическая форма         Форма с плавающей точкой
 1 000 000         1106                       1.0000000000Е+06
 -123.452          -1.23452102                -1.2345200000Е+02
 0.0056712         5.671210-3                 5.6712000000Е-03

     2.3.2 Строковые и символьные константы

    Строковые и символьные константы заключаются в кавычки. Примеры строковых констант: 'Язык
программирования Delphi', 'Delphi 7', '2.4', 'Д'.
    Здесь следует обратить внимание на константу '2.4'. Это именно символьная константа, т. е. строка
символов, которая изображает число «две целые четыре десятых», а не число 2,4.

     2.3.3 Логические константы

     Логическое высказывание (выражение) может быть либо истинно, либо ложно. Истине соответствует
константа True, значению «ложь» – константа False.

     2.3.4 Именованные константы

     Именованная константа  это имя (идентификатор), которое в программе используется вместо самой
константы.
     Именованная константа, как и переменная, перед использованием должна быть объявлена. В общем
виде инструкция объявления именованной константы выглядит следующим образом:
     константа = значение;
     где:
      константа  имя константы;
      значение  значение константы.
     Именованные константы объявляются в программе в разделе объявления констант, который
начинается словом const. Ниже приведен пример объявления именованных констант (целой, строковой и
дробной).
     const
        Bound = 10;
        Title = ’Скорость бега’;
        pi = 3.1415926;

     После объявления именованной константы в программе вместо самой константы можно
использовать ее имя.
     В отличие от переменной, при объявлении константы тип явно не указывают. Тип константы
определяется ее видом, например:
      125  константа целого типа;
      0.0  константа вещественного типа;
      ' выполнить '  строковая константа;
      ' \'  символьная константа

     2.4 Стандартные функции

     Для выполнения часто встречающихся вычислений и преобразований язык Delphi предоставляет
программисту ряд стандартных функций.
     Значение функции связано с ее именем. Поэтому функцию можно использовать в качестве операнда
выражения, например, в инструкции присваивания. Так, чтобы вычислить квадратный корень, достаточно
записать k:=Sqrt(n), где Sqrt  функция вычисления квадратного корня, n  переменная, которая
содержит число, квадратный корень которого надо вычислить.
     Функция характеризуется типом значения и типом параметров. Тип переменной, которой
присваивается значение функции, должен соответствовать типу функции. Точно так же тип фактического
параметра функции, т. е. параметра, который указывается при обращении к функции, должен
соответствовать типу формального параметра. Если это не так, компилятор выводит сообщение об
ошибке.

26
     2.4.1 Математические функции

     Математические функции (таблица 2.4) позволяют выполнять различные вычисления.

Таблица 2.4 – Математические функции
   Функция                          Значение
   Аbs (n)        Абсолютное значение n
   Sqrt (n)       Квадратный корень из n
   Sqr (n)        Квадрат n
   Sin (n)        Синус n
   Cos (n)        Косинус n
   Arctan (n)     Арктангенс n
   Ехр(n)         Экспонента n
   Ln(n)          Натуральный логарифм n
   Rardom(n)      Случайное целое число в диапазоне от 0 до n-1

     Величина угла тригонометрических функций должна быть выражена в радианах. Для
преобразования величины угла из градусов в радианы используется формула (а*3.1415926)/180, где
а  величина угла в градусах; 3.1415926  число . Вместо дробной константы 3.1415926 можно
использовать стандартную именованную константу Pi. В этом случае выражение пересчета угла из
градусов в радианы будет выглядеть так: a*Pi/180.

     2.4.2 Функции преобразования

     Функции преобразования (таблица 2.5) наиболее часто используются в инструкциях,
обеспечивающих ввод и вывод информации. Например, для того чтобы вывести в поле вывода (компонент
Label) диалогового окна значение переменной типа real, необходимо преобразовать число в строку
символов, изображающую данное число. Это можно сделать при помощи функции FloatToStr, которая
возвращает строковое представление значения выражения, указанного в качестве параметра функции.
     Например, инструкция Label1.Сaption:=FloatToStr(x) выводит значение переменной х в
поле Label1.

Таблица 2.5 – Функции преобразования
        Функция                                          Значение функции
 Chr(n)                     Символ, код которого равен n
 IntToStr (k)               Строка, являющаяся изображением целого
 FloatToStr (n)             Строка, являющаяся изображением вещественного n
                            Строка, являющаяся изображением вещественного n. При вызове функции
 FloatToStrF(n, f , k, m)   указывают: f  формат (способ изображения); k  точность (нужное общее
                            количество цифр); m  количество цифр после десятичной точки
 StrToInt (s)               Целое, изображением которого является строка s
 StrToFloat (s)             Вещественное, изображением которого является строка s
 Round (n)                  Целое, полученное путем округления n по известным правилам
 Trunc (n)                  Целое, полученное путем отбрасывания дробной части n
 Frac(n)                    Дробное, представляющее собой дробную часть вещественного n
 Int (n)                    Дробное, представляющее собой целую часть вещественного n

     2.5 Использование функций

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

     N:=Round((x2-x1)/dx);
     x1:=(-b + Sqrt(d))/(2*а);
     m:=Random(10);
     cena:=StrToInt(Edit1.Text);
     Edit2.Text:=IntToStr(100);
     mes:=’x1=’ + FloatToStr(xl);


                                                                                                     27
     2.6 Оператор присваивания

     Инструкция присваивания является основной вычислительной инструкцией. Если в программе надо
выполнить вычисление, то нужно использовать инструкцию присваивания. В результате выполнения этой
инструкции значение переменной меняется, ей присваивается значение. В общем виде инструкция
присваивания выглядит так:
     имя:= выражение;
     где:
      имя  переменная, значение которой изменяется в результате выполнения инструкции
присваивания;
      : =  символ инструкции присваивания;
      выражение  выражение, значение которого присваивается переменной, имя которой указано
слева от символа инструкции присваивания.
     Наример: Surama:=Сеnа*Kol; Skidka:=10; Found:=False;

     2.7 Ввод данных

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

     2.7.1 Ввод из поля редактирования

     Поле редактирования  это компонент Edit. Ввод данных из поля редактирования осуществляется
обращением к свойству Text. На рисунке 2.1 приведен вид диалогового окна программы пересчета массы
из фунтов в килограммы. Компонент Edit1 используется для ввода исходных данных. Инструкция ввода
данных в этом случае будет иметь вид: Funt:= StrToFloat(Edit1.Text);




                   Рисунок 2.1 – Компонент Edit1, используемый для ввода данных

     2.8 Вывод результатов

    Наиболее просто программа может вывести результат своей работы в окно сообщения или в поле
вывода (компонент Label) диалогового окна

     2.8.1 Вывод в поле диалогового окна

     Часть диалогового окна, предназначенная для вывода информации, называется полем вывода, или
полем метки. Поле вывода  это компонент Label. Содержимое поля вывода определяется значением
свойства Caption.
     Для того чтобы во время работы программы изменить содержимое поля вывода, например, вывести в
поле результат работы программы, нужно присвоить свойству новое значение.
     На рисунке 2.2 изображено диалоговое окно программы пересчета веса из фунтов в килограммы.
Окно содержит два компонента Label. Компонент Label1 обеспечивает вывод информационного
сообщения, компонент Label2  вывод результата работы программы.



28
                 Рисунок 2.2 – Поле Label2 для вывода результата работы программы

     Свойство Caption символьного типа. Поэтому, для того, чтобы во время работы программы вывести в
поле метки числовое значение, нужно преобразовать число в строку при помощи функции FloatToStr или
IntToStr. Например, для преобразования числа для переменной ft вещественного типа в строку вводится
функция FloatToStrF(ft,ffFixed,5,2), которая отводит под запись числа пять позиций, из которых две
позиции – под дробную часть числа.
     Ниже в качестве примера приведен оператор из программы пересчета массы из фунтов в
килограммы, который используется для вывода результата расчета.
                          Label2.Caption:=FloatToStr(kg)+' кг';

    2.8.2 Вывод в поле многострочного окна Меmо

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

представлено компонентом ТMemo. Для этого надо выбрать в меню компонентов кнопку                    и
поместить компонент ТМеmо на форму. С помощью мыши регулируют его размеры и местоположение.
После установки с помощью инспектора свойства ScrollBars  SSBoth в окне появятся вертикальная и
горизонтальная полосы прокрутки.
     В тексте программы появится переменная Memo1 типа ТMemo. Информация, которая отображается
построчно в окне типа ТMemo, находится в массиве строк Memo1.Lines. Каждая строка имеет тип string.
     Для чистки окна используется метод Memo1.Сlеаr. Для того чтобы добавить новую строку в окно,
используется метод Memo1.Lines.Add (переменная типа string).
     Если нужно вывести число, находящееся в переменной действительного или целого типа, то его надо
предварительно преобразовать к типу string и добавить в массив Memo1.Lines.
     Например, если переменная u целого типа, то метод Memo1.Line.Add ('Значение u='+IntToStr(u))
сделает это, и в окне появится строка «Значение u=100». Если переменная u:=-256,38666 действительная,
то при использовании метода Memo1.Lines.Add ('Значение u='+FloatToStrF(u,ffFixed,8,2)) будет выведена
строка «Значение u= -256.39». При этом под все число отводится восемь позиций, из которых две позиции
занимает его дробная часть.
     Если число строк в массиве Memo1 превышает размер окна, то для просмотра всех строк
используется вертикальная полоса прокрутки. Если длина строки Memo1 превосходит количество
символов в строке окна, то в окне отображается только начало строки. Для просмотра всей строки
используется горизонтальная полоса прокрутки.

    2.9 Процедуры и функции

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

                                                                                                  29
     2.9.1 Структура процедуры

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

     procedure имя (список параметров);
      const
       // здесь объявления констант
      type
       // здесь объявления типов
      var
       // здесь объявления переменных
        begin
           // здесь инструкции программы
        end;

     Заголовок процедуры состоит из слова procedure, за которым следует имя процедуры, которое
используется для вызова процедуры, активизации ее выполнения. Если у процедуры есть параметры, то
они указываются после имени процедуры в скобках. Завершается заголовок процедуры символом «точка с
запятой».
     Если в процедуре используются именованные константы, то они объявляются в разделе объявления
констант, который начинается словом const. Раздел объявления типов начинается словом type. В разделе
объявления переменных объявляются (перечисляются) все переменные, используемые в программе.
Раздел объявления переменных начинается со слова var.
     После раздела объявления объектов следует раздел инструкций. Раздел инструкций начинается
словом begin и заканчивается словом end, за которым следует символ «;». В разделе инструкций
находятся исполняемые инструкции процедуры.
     Фрагмент программы пересчета фунтов в килограммы:

     procedure TForm1.Button1Click(Sender: Tobject);
       var ft,kg:real;
          mes: string[255]; // сообщение
           begin
             ft:=StrToFloat(Form1.Edit1.Text);// считывание символов из поля
         редактирования и преобразование их в числа вещественного типа
             kg:=ft*0.4095;// перевод фунтов в кг
             //формируется строка вывода
               mes:=FloatToStrF(ft,ffFixed,5,2)+
               'фунтов в пересчете на кг составляет '
               + FloatToStrF(kg,ffFixed,5,2) +’ кг’;
             Form1.Label2.Caption:= mes;// в метку 2 будет выведено сообщение
           end;

     2.9.2 Структура функции

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

     function имя (список параметров):тип;
     const // начало раздела объявления констант
     type // начало раздела объявления типов
     var // начало раздела объявления переменных
     begin // начало раздела инструкций
     result:=значение; // связать с именем функции значение
     end;




30
     Заголовок функции начинается словом function, за которым следует имя функции. После имени
функции в скобках приводится список параметров, за которым через двоеточие указывается тип значения,
возвращаемого функцией (тип функции). Завершается заголовок функции символом «точка с запятой».
     За заголовком функции следуют разделы объявления констант, типов и переменных.
     В разделе инструкций, помимо переменных, перечисленных в разделе описания переменных, можно
использовать переменную result. По завершении выполнения инструкций функции значение этой
переменной становится значением функции. Поэтому среди инструкций функции обязательно должна
быть инструкция, присваивающая переменной result значение. Как правило, эта инструкция является
последней исполняемой инструкцией функции.
     Вот как выглядит подпрограмма, оформленная в виде функции, которая пересчитывает массу из
фунтов в килограммы:

    // пересчет массы из фунтов в килограммы
    function FuntToKg(f:real):real;
    const
       // в России 1 фунт равен 409,5 гр.
       К=0.4095; // коэф. пересчета
    begin
       result:=f*K;
    end;

    2.10 Запись операторов программы

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

    st:= 'Корни уравнения'+ #13
    +'x1=' + FloatToStr(x1)+ #13 +'х2=' + FloatToStr(x2);

     Код #13 соответствует клавише «enter»  переводу курсора на новую строку. Компилятор
игнорирует «лишние» пробелы и пустые строки.
     Для облегчения понимания логики работы программы в текст программы нужно включать
поясняющий текст  комментарии. В общем случае комментарии заключают в фигурные скобки.
Открывающая скобка помечает начало комментария, закрывающая  конец. Если комментарий
однострочный или находится после инструкции, то перед комментарием ставят две наклонные черты.
     Пример раздела объявления переменных, в котором использованы оба способа записи комментариев:

    var
      {коэффициенты уравнения}
         a:real; // при второй степени неизвестного
         b:real; // при первой степени неизвестного
         с:real; // при нулевой степени неизвестного
      {корни уравнения} x1,x2:real;

    2.11 Стиль программирования

     Работая над программой, программист должен хорошо представлять, что программа, которую он
разрабатывает, предназначена, с одной стороны, для пользователя, с другой  для самого программиста.
Текст программы нужен прежде всего самому программисту, а также другим людям, с которыми он
совместно работает над проектом. Поэтому для того, чтобы работа была эффективной, программа должна
быть легко читаемой, ее структура должна соответствовать структуре и алгоритму решаемой задачи. Как
этого добиться? Надо следовать правилам хорошего стиля программирования. Стиль программирования 
это набор правил, которым следует программист (осознано или потому, что «так делают другие») в
процессе своей работы. Очевидно, что хороший программист должен следовать правилам хорошего стиля.
     Хороший стиль программирования предполагает:
      использование комментариев;
      использование несущих смысловую нагрузку имен переменных, процедур и функций;
      использование отступов;
      использование пустых строк.
                                                                                                 31
     Четкого критерия оценки степени соответствия программы хорошему стилю программирования не
существует. Вместе с тем достаточно одного взгляда, чтобы понять, соответствует программа хорошему
стилю или нет.
     Сводить понятие стиля программирования только к правилам записи текста программы было бы
неверно. Стиль, которого придерживается программист, проявляется во время работы программы.
Хорошая программа должна быть прежде всего надежной и дружественной по отношению к
пользователю.
     Надежность подразумевает, что программа, не полагаясь на «разумное» поведение пользователя,
контролирует исходные данные, проверяет результат выполнения операций, которые по какой-либо
причине могут быть не выполнены, например, операций с файлами.
     Дружественность предполагает хорошо спроектированные диалоговые окна, наличие справочной
системы, разумное и предсказуемое, с точки зрения пользователя, поведение программы.

     2.12 Лабораторная работа №2. Программирование линейных алгоритмов

     Цель работы: научиться создавать приложения в среде Delphi с использованием компонентов Edit,
Label, Botton, Memo. Написать и отладить программу линейного алгоритма.

       Пример 1. Составить программу вычисления арифметического выражения для заданных значений
х, у, z:
                                u  tg 2 x  y   e y  z  cosx 2   sin z 2  .

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




                                    Рисунок 2.3 – Панель диалога

               Последовательность выполнения действий по созданию приложения

     Изменение заголовка формы

     Новая форма имеет одинаковые имя (Name) и заголовок (Caption)  Form1. Имя формы менять не
рекомендуется, т.к. оно входит в текст программы.
     Для изменения заголовка формы в окне инспектора объектов найдите и щелкните мышью на
Properties – Caption. В текстовом поле введите заголовок, как указано на рисунке 2.3.

     Размещение строки ввода (TEdit)

      Если необходимо ввести из формы в программу или вывести на форму информацию, которая
вмещается в одну строку, используют окно однострочного редактора текста, представляемого
компонентом TEdit.
      В данной программе с помощью однострочного редактора будут вводиться переменные х, у, z типа
real или integer.


32
     Выберите в меню компонентов Standard пиктограмму        , щелкните мышью в том месте формы,
где вы хотите ее поставить. Вставьте три компонента TEdit в форму. Захватывая их «мышью»,
отрегулируйте размеры окон и их положение. Обратите внимание на то, что в тексте программы
появились три новых однотипных переменных Edit1, Edit2, Edit3. В каждой из этих переменных
расширением .Text будет содержаться строка символов (тип string) и отображаться в соответствующем
окне Edit.
     Так как численные значения переменных х, у, z имеют действительный тип, то для преобразования
строковой записи числа, находящегося в переменной Edit.Text, в действительное, используется
стандартная функция x:=StrToFloat(Edit1.Text).
     Если исходные данные имеют целочисленный тип, например integer, то используется стандартная
функция х:=StrToInt(Edit1.Text).
     При этом в записи числа не должно быть пробелов, а действительное число пишется с десятичной
запятой.
     С помощью инспектора объектов установите шрифт и размер символов, отображаемых в строке Edit
(свойство Font).

     Размещение надписей (TLabel)

     На форме (см. рисунок 2.3) имеются четыре пояснительные надписи. Для нанесения таких надписей
на форму используется компонент TLabel. Выберите в меню компонентов Standard пиктограмму           ,
щелкните на ней мышью. После этого в нужном месте формы щелкните мышью, появится надпись Label1.
Проделайте это для четырех надписей. Для каждой надписи отрегулируйте размер и, изменив свойство
Caption инспектора объектов, введите строку, например «Введите значение x:», а также выберите размер
символов (свойство Font).
     Обратите внимание, что в тексте программы автоматически появились четыре новых переменных
типа TLabel. В них хранятся пояснительные строки, которые можно изменять в процессе работы
программы.

     Размещение многострочного окна вывода (ТМеmо)

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

представлено компонентом ТMemo. Выберите в меню компонентов пиктограмму        и поместите
компонент ТМеmо на форму. С помощью мыши отрегулируйте его размеры и местоположение. После
установки с помощью инспектора свойства ScrollBars  SSBoth в окне появятся вертикальная и
горизонтальная полосы прокрутки.
     В тексте программы появилась переменная Memo1 типа ТMemo.

     Написание процедуры обработки события создания формы (FormCreate)

     При запуске программы возникает событие «создание формы» (OnCreate). Создайте программу –
обработчик этого события, которая заносит начальные значения переменных х, у, z в соответствующие
окна TEdit, а в окне TMemo помещает строку с указанием номера группы и фамилии студента. Для этого
дважды щелкнете мышью на любом свободном месте формы. На экране появится текст, в котором
автоматически внесен заголовок процедуры  обработчика события создания формы: Procedure
TForm1.FormCreate(Sender: TObject). Между begin и end вставьте текст программы (см. листинг 2.1).

     Написание программы обработки события нажатия кнопки (ButtonClick)

     Поместите на форму кнопку, которая описывается компонентом TButton, для чего выберете в меню
компонентов Standard пиктограмму      . С помощью инспектора объектов измените заголовок (Caption) 
Button1 на слово «Выполнить» или другое по вашему желанию. Отрегулируйте положение и размер
кнопки. Разместите также кнопку «Завершить».
     Перейдите на вкладку Events (события) окна инспектора событий и в левом столбце найдите
название события – OnButtonClick . После двойного щелчка в правом поле данной строки автоматически
появляется окно кода процедуры, дополненной заголовком процедуры обработчика события  нажатия
кнопки (Procedure TForm1.Button1Click(Sender: TObject);). Наберите текст этой процедуры, приведенный в
примере.
     Дважды щелкните по кнопке «Завершить». В появившейся процедуре обработчика события опишите
действие выхода из программы с помощью метода close (см. Procedure TForm1.Button2Click (Sender:
TObject)).

                                                                                                   33
     Запуск и работа с программой
     Запустить программу можно, нажав Run в главном меню Run, или клавишу F9, или пиктограмму .
При этом происходит трансляция и, если нет ошибок, компоновка программы и создание единого
загружаемого файла с расширением .exe. На экране появляется активная форма программы. Запустить
программу можно также двойным щелчком по имени исполняемого файла (с расширением .exe).
     Работа с программой происходит следующим образом. Нажмите (щелкните мышью) кнопку
«Выполнить». В окне Memo1 появляется результат. Измените исходные значения х, у, z в окнах Edit и
снова нажмите кнопку «Выполнить»  появятся новые результаты. Для окончания работы программы
нажмите на кнопку «Завершить».

     Листинг 2.1 Текст модуля вычисления арифметического выражения

    unit Unit1;
    interface
    uses
      Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls,
Forms,
      Dialogs, StdCtrls;
    type
      TForm1 = class(TForm)
         Label1: TLabel;
         Label2: TLabel;
         Label3: TLabel;
         Label4: TLabel;
         Edit1: TEdit;
         Edit2: TEdit;
         Edit3: TEdit;
         Button1: TButton;
         Button2: TButton;
         Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
      private
         { Private declarations }
      public
         { Public declarations }
      end;
    var
      Form1: TForm1;
    implementation
    {$R *.dfm}

     procedure TForm1.FormCreate(Sender: TObject);
       begin
         Edit1.Text:='3,4';         // начальное значение x
         Edit2.Text:='0,74';        // начальное значение y
         Edit3.Text:='19,43';       // начальное значение z
         Memo1.Clear;              // очистка окна редактора Memo1
             // вывод строки в многострoчный редактор Memo1
         Memo1.Lines.Add('Лаб. Раб.№1. Ст. гр. БТ-61 Иванова А.И.');
        end;

     procedure TForm1.Button1Click(Sender: TObject);
     var
       x, y, z, a, b, c, u: real;
         begin
          x:=StrToFloat(Edit1.Text);           // считывание значения x
          Memo1.Lines.Add('x = '+Edit1.Text); // вывод х в окно Memo1
          y:=StrToFloat(Edit2.Text);         // считывание значения y
          Memo1.Lines.Add('y = '+Edit2.Text);// вывод y в окно Memo1
          z:=StrToFloat(Edit3.Text);        // считывание значения z
          Memo1.Lines.Add('z = '+Edit3.Text); // вывод z в окно Memo1

34
         // вычисление арифметического выражения
    a:=Sqr(Sin(x+y)/Cos(x+y));
    b:=Exp(y-z);
    c:=Sqrt(Cos(Sqr(x))+Sin(Sqr(z)));
    u:=a-b*c;
        // вывод результатов в окно Memo1
    Memo1.Lines.Add('Результат U = '+FloatToStrF(u,ffFixed,8,3));
   end;

    procedure TForm1.Button2Click(Sender: TObject);
      begin
         Form1.Close;
      еnd;
    end.

    2.13 Выполнение индивидуального задания

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

   Номер                                                                              Исходные
                                                                      Выражение
  варианта                                                                             данные
     1               
              a  ln y
                    
                                  x   
                                        * sin x   e
                                       
                                                       x  y                   x, y

     2        b       c y  x * cosx   c  y 
                                            2                                     c, x, y
     3                        3             x y                                  b, x, y
              с  arctg ( x)  e xy  0,5
                                           x  y
                                                   b
                              5
                                  tg z 
                           x y
     4                                                                            x, y, z
                                                 lnx 
                       e
              d
                    arctg  y             x
     5        e
                   cosx   sin  y 3  ln 2 xyz                            x, y, z
                           tg z 

     6                                              z 3 sin 2  y                x, y, z
              f  yx             x  ey 
                                                          z2
                                                    y
                                                        y  x
     7                1  cosx  y                                              x, y
              g                                    x 3  arcsin y 
                                       2y
                     ex 
                               1  x y 2      2


     8                         x2   y 3 z 4  ln  x   1 2                     x, y, z
              h  2                  
                                2    2               3
     9                                    yx 
                                                                        3         x, y, z
              j   1  y  sin 2  z       
                                           5 
     10                                                                         x, y, z
                                    y 
                           
              k  ln y  x   x 
                             
                                         
                                      x2 
                                                
                                  z 
                                     4 
     11       Найти сумму цифр заданного четырехзначного числа n                  n
     12       Определить число, полученное в обратном порядке цифр                n
              заданного трехзначного числа n
     13       Присвоить целой переменной k третью от конца цифру в                n
              записи положительного целого числа n
     14       Целой переменной s присвоить сумму цифр трехзначного                n
              целого числа n
     15       Идет k-я секунда суток. Определить, сколько полных часов            k
              (h) и полных минут (m) прошло к этому моменту



                                                                                                 35
          3 ИСПОЛЬЗОВАНИЕ КОМПОНЕНТОВ ОРГАНИЗАЦИИ ПЕРЕКЛЮЧЕНИЙ.
               ПРОГРАММИРОВАНИЕ РАЗВЕТВЛЯЮЩИХСЯ АЛГОРИТМОВ

         3.1 Кнопки-переключатели в Delphi

     При создании программ в Delphi для организации разветвлений часто используются компоненты в
виде кнопок-переключателей. Состояние такой кнопки (включено  выключено) визуально отражается на
форме. На форме (см. рисунок 3.1) представлены кнопки-переключатели двух типов (TCheckBox,
TRadioGroup). Для организации выбора также может использоваться список  компонент ТListBox.
     Компонент TCheckBox организует кнопку независимого переключателя, с помощью которой
пользователь может указать свое решение типа да/нет. В программе состояние кнопки связано со
значением булевской переменной, которая проверяется с помощью условного оператора.
     Компонент TRadioGroup организует группу кнопок  зависимых переключателей. При нажатии
одной из кнопок группы все остальные кнопки отключаются. В программу передается номер включенной
кнопки (0, 1, 2,..), который анализируется с помощью оператора выбора case.
     Компонент ListBox позволяет создать список для выбора одного элемента.

         3.2 Разветвляющиеся алгоритмы

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

         3.2.1 Условие

     В программе условие  это выражение логического типа (boolean), которое может принимать одно из
двух значений: True (истина) или False (ложь). Простое условие состоит из двух операндов и операции
сравнения. В общем виде условие записывается следующим образом:
     Оn1 операция On2
     где:
      On1 и Оn2  операнды условия, в качестве которых могут выступать переменная, константа,
функция или выражение;
      операция  операция сравнения.
     В языке Delphi есть шесть операций сравнения, которые приведены в таблице 3.1.

Таблица 3.1 – Операции сравнения
     Операция            Описание                     Результат сравнения
                                      True, если первый операнд больше второго, иначе
     >             Больше
                                      False
                                      True, если первый операнд меньше второго, иначе
     <             Меньше
                                      False
                                      True, если первый операнд равен второму,
     =             Равно
                                      иначеFalse
                                      True, если первый операнд не равен второму, иначе
     <>            Не равно
                                      False
                                      True, если первый операнд больше или равен
     >=            Больше или равно
                                      второму, иначе False
                                      True, если первый операнд меньше или равен
     <=            Меньше или равно
                                      второму, иначе False

      Примеры записи условий: Summa<1000; S>=H; Sim=Chr(13).
      В первом примере операндами условия являются переменная и константа. Значение этого условия
зависит от значения переменной Summa. Условие будет верным и, следовательно, иметь значение True,
если значение переменной Summa меньше, чем 1000. Если значение переменной Summa больше или равно
1000, то значение этого условия будет False.
      Во втором примере в качестве операндов используются переменные. Значение этого условия будет
True, если значение переменной S больше или равно значению переменной H.
      В третьем примере в качестве второго операнда используется функция. Значение этого условия будет
True, если в переменной Sim находится символьный код клавиши <Enter>, равный 13.


36
     При записи условий следует обратить особое внимание на то, что операнды условия должны быть
одного типа или, если тип операндов разный, то тип одного из операндов может быть приведен к типу
другого операнда. Например, если переменная Key объявлена как integer, то условие Key=Chr(13)
синтаксически неверное, т. к. значение возвращаемое функцией Chr имеет тип char (символьный). Во
время трансляции программы при обнаружении неверного условия компилятор выводит сообщение:
incompatible types (несовместимые типы).
     Из простых условий при помощи логических операций: and  «логическое И», or – «логическое
ИЛИ» и not  «отрицание» можно строить сложные условия.
     В общем виде сложное условие записывается следующим образом:
     условие1 операция условие2
     где:
      условие1 и условие2  простые условия (выражения логического типа);
      операция  операция and или or.
     Примеры:

    (ch >= ’0’) and (ch <= ’9’)
    (day = 7) or (day = 6)
    (Forml.Editl.Text <> ’ ’ ) or (Forml.Edit2.Text <> ’ ’ )
    Forml.CheckBoxl.Checked and (Forml.Editl.Text <> ’ ’ )

    Результат выполнения логических операций and, or и not представлен в таблице 3.2.

Таблица 3.2 – Выполнение логических операций
   Op1       Op2      Op1 and Op2      Op1 or Op2       not Op1
 False    False       False           False           True
 False    True        False           True            True
 True     False       False           True            False
 True     True        True            True            False

     При записи сложных условий важно учитывать то, что логические операции имеют более высокий
приоритет, чем операции сравнения, и поэтому простые условия следует заключать в скобки.
     Например, пусть условие предоставления скидки сформулировано следующим образом: «Скидка
предоставляется, если сумма покупки превышает 100 руб. и день покупки  воскресенье». Если день
недели обозначен как переменная Day целого типа, и равенство ее значения семи соответствует
воскресенью, то условие предоставления скидки можно записать: (Summa > 100) and (Day = 7).
     Если условие предоставления скидки дополнить тем, что скидка предоставляется в любой день, если
сумма покупки превышает 500 руб., то условие можно записать:
                     ((Summa > 100) and (Day =7)) or (Summa > 500).

    3.2.2 Выбор

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

    3.2.3 Инструкция if

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

    if условие then
       begin
    // здесь инструкции, которые надо выполнить,
    // если условие истинно
       end
    else
       begin
    // здесь инструкции, которые надо выполнить,
    // если условие ложно
       end;

                                                                                                 37
     Обратите внимание, что перед else (после end) точка с запятой не ставится.
     Выполняется инструкция if следующим образом:
      вычисляется значение условия (условие  выражение логического типа, значение которого может
быть равно True или False);
      если условие истинно (значение выражения условие равно True), то выполняются инструкции,
следующие за словом then (между begin и end); – на этом выполнение операции if заканчивается, то есть
инструкции, следующие за else, не будут выполнены;
      если условие ложно (значение выражения условие равно False), то выполняются инструкции,
следующие за словом else (между begin и end).
     Например, необходимо вычислить функцию в зависимости от значений аргументов:

                                     i a, если i  нечетное a  0;
                                                              ,
                                     
                                     i
                                   y    a , если i  четное, a  0;
                                     2
                                      i * a , иначе.
                                     

     Условный оператор будет записан таким образом:
     if (a>0) and (I mod 2 <> 0) then y:=i*sqrt(a) else
     if (a<0) and (I mod 2 = 0) then y:=i/2*sqrt(abs(a)) else
     y:=sqrt(abs(i*a));
     В этом примере необходимо реализовать три направления вычислений, но так как условный
оператор позволяет делить вычислительный процесс только на два направления, приходится структуру if
употреблять дважды.
     Если в инструкции if между begin и end находится только одна инструкция, то слова begin и end
можно не писать. Например, инструкцию
    if otv=3 then
          begin
          prav:=prav+1;
          end
    else
           begin
          ShowMessage('Ошибка!');
           end;
можно переписать так:
     if otv=3 then prav:=prav+l else ShowMessage('Ошибка!');
     Допускается и так называемая усеченная конструкция условного оператора, когда отсутствует
инструкция после then или else. Например:
     if условие then
           begin
           { инструкции, которые надо выполнить, если условие выполняется}
           end;
     Например, оператор if n=m then k:=k+1; увеличивает значение переменной k только в том
случае, если значения переменных n и m равны.

     3.2.4 Инструкция goto

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


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

     3.2.5 Инструкция case

    В языке Delphi есть инструкция case, которая позволяет эффективно реализовать множественный
выбор. В общем виде она записывается следующим образом:
     case ключ выбора of
     список 1: begin
              {инструкции 1}
              end;
     список 2: begin
              {инструкции 2}
              end;
     список N: begin
              {инструкции N}
              end;
     else
              begin
             {инструкции)
              end;
     end;
     где:
      ключ выбора  выражение, значение которого определяет дальнейший ход выполнения
программы (т. е. последовательность инструкций, которая будет выполнена);
      список N  список констант. Если константы представляют собой диапазон чисел, то вместо
списка можно указать первую и последнюю константы диапазона, разделив их двумя точками. Например,
список 1, 2, 3, 4, 5, 6 может быть заменен диапазоном 1..6.
     Выполняется инструкция case следующим образом:
      сначала вычисляется значение выражения-ключа выбора;
      значение ключа последовательно сравнивается с константами из списков констант;
      если значение ключа совпадает с константой из списка, то выполняется соответствующая этому
списку группа инструкций, и на этом выполнение инструкции саsе завершается;
      если значение ключа не совпадает ни с одной константой из всех списков, то выполняется
последовательность инструкций, следующая за else.
     Синтаксис инструкции case позволяет не писать else и соответствующую последовательность
инструкций. В этом случае, если значение выражения не совпадает ни с одной константой из всех списков,
то выполняется следующая за case инструкция программы.
     Пример. Ниже приводится три варианта решения одной и той же задачи: если число n_day имеет
значение от 1 до 5, то вывести на экран сообщение, что это рабочий день, если значение равно 6 или 7, то
соответственно назвать дни недели – суббота или воскресенье.
     case n_day     of
     1,2,3,4,5:     day:='Рабочий день' ;
             6:    day:='Cyббoтa!';
             7:    day:='Воскресенье!';
     end;

     case n_day of
          1..5: day:='Рабочий день';
          6: day:='Суббота!';
          7: day:='Воскресенье!';
     end;

     case n_day of
          6: day:='Суббота!'
          7: day:='Воскресенье!';
     else day:='Рабочий день';
     end;




                                                                                                     39
     3.3 Лабораторная работа №3. Программирование разветвляющихся алгоритмов
    Цель работы: научиться создавать приложения в среде Delphi с использованием компонентов
TCheckBox, TRadioGroup, TListBox. Написать и отладить программу разветвляющегося алгоритма.

      Пример 1. Составить программу вычисления функций u=sin(x), u=cos(x) и u=tg(х) для заданных
х, у, z. Выбор вида функции для вычисления ее значения должен осуществляться пользователем в ходе
работы программы. В программе предусмотреть также вычисление максимального из трех чисел:
max(x, у, z), или min (|x|, |у|, |z|) (по выбору пользователя).

                            Последовательность разработки приложения

     Создание формы

     Создайте новую форму, вид которой показан на рисунке 3.1.




                                 Рисунок 3.1 – Вид формы в примере 1

      Введите в форму три метки с поясняющими надписями. Ниже расположите три окна редактирования
для ввода чисел для переменных x, y, z. Еще ниже расположите многострочное окно Memo для вывода
результатов работы программы. При этом следует снабдить окно вертикальной линейкой прокрутки, т.к.
строк может быть много, и не все данные можно увидеть в окне. Для этого воспользуйтесь свойством
Scrollbars и выберите ssVertical. Все кнопки расположены на стандартной панели (см. рисунок 1.2).

     Работа с компонентом TCheckBox

     Выберите в меню компонентов Standard пиктограмму компонента CheckBox и поместите ее в
нужное место формы. С помощью инспектора объектов измените заголовок (Caption) на «вычисление
выражения». В тексте программы появилась переменная CheckBox типа TCheckBox. Теперь в
зависимости от того, нажата или нет кнопка, булевская переменная CheckBox.Checked будет принимать
значения True или False.

     Работа с компонентом TRadioGroup

      Выберите в меню компонентов Standard пиктограмму для компонента TRadioGroup и поместите ее в
нужное место формы. На форме появится окаймленный линией чистый прямоугольник с заголовком
RadioGroup1. Замените заголовок (Caption) на U(х). Для того чтобы разместить на компоненте кнопки,
необходимо свойство Columns установить равным единице (кнопки размещаются в одном столбце).
Дважды щелкните по правой части свойства Items мышью, появится строчный редактор списка
заголовков кнопок. Наберите три строки с именами: в первой строке sin(x), во второй  cos(х), в третьей 
tg(х), нажмите ОК.
      После этого на форме внутри окаймления появится три кнопки-переключателя с введенными
надписями.
      Обратите внимание на то, что в тексте программы появилась переменная RadioGroup типа
TRadioGroup. Теперь при нажатии одной из кнопок группы в переменной целого типа

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

    Создание обработчиков событий FormCreate и Botton1Click, Botton2Click

     Процедуры  обработчики событий FormCreate и Botton1Click создаются аналогично тому, как и в
первой теме. Текст процедур приведен в листинге 3.1.
     Запустите программу и убедитесь в том, что все ветви алгоритма выполняются правильно.
     Фрагмент кода программы с процедурами создания формы, двумя кнопками обработки события
приведен ниже.
Листинг 3.1 Текст процедур обработчиков событий

    procedure TForm1.FormCreate(Sender: TObject);
      begin
         Edit1.Text:='3,4';     // начальное значение x
         Edit2.Text:='0,74';     // начальное значение y
         Edit3.Text:='19,43';    // начальное значение z
         Memo1.Clear;            // очистка экрана Memo1
         // вывод в многострочное окно Memo1
         Memo1.Lines.Add('Лаб. раб №2. Ст. гр. БТ-61 Иванова А.В.');
      end;
    // процедура обработки события нажатия кнопки «Вычислить»

    procedure TForm1.Button1Click(Sender: TObject);
     var x, y, z, u, ma,min: real;
      begin
                // ввод исходных данных и их вывод в окно Memo1
         x:=StrToFloat(Edit1.Text);
                Memo1.Lines.Add('x='+Edit1.Text);
         y:=StrToFloat(Edit2.Text);
                Memo1.Lines.Add('y='+Edit2.Text);
         z:=StrToFloat(Edit3.Text);
                Memo1.Lines.Add('z='+Edit3.Text);
         // проверка номера нажатой кнопки и вычисление соответствующей ей
     функции
         case RadioGroup1.ItemIndex of
                      0: u:=cos(x);
                      1: u:=sin(x);
                      2: u:=sin(x)/cos(x);
         end;
           Memo1.Lines.Add('u='+FloatToStrF(u,ffFixed,8,2));
         // проверка состояния кнопки СheckBox1
         if CheckBox1.Checked then // если включена кнопка, то вычисляем
     модули чисел
                 begin
                      x:=abs(x);
                      y:=abs(y);
                      z:=abs(z)
                 end;
         // нахождение максимального из трех чисел
                     if x>y then ma:=x else ma:=y;
                     if z>ma then ma:=z;
         // если включена кнопка, то вычисляем минимальное из модулей чисел и
     выводим результат, иначе выводим максимальное из трех чисел
         if CheckBox1.Checked then
                 begin
                      if x<y then min:=x else min:=y;
                      if z<min then min:=z;
                      Memo1.Lines.Add(' minabs='+FloatToStrF(min,ffFixed,8,2))
                 end
                 else
         Memo1.Lines.Add('max='+FloatToStrF(ma,ffFixed,8,2));
      end;

                                                                                              41
     // процедура завершения программы
     procedure TForm1.Button2Click(Sender: TObject);
       begin
           Form1.Close
       end;

     Пример 2. Составить программу, которая пересчитывает массу из фунтов в килограммы. Программа
учитывает, что в разных странах фунт «весит» по-разному. Например, в России фунт равен 409,5 граммов,
в Англии  453,592 грамма, а в Германии, Дании и Исландии фунт весит 500 граммов.
     В диалоговом окне программы, изображенном на рисунке 3.2, для выбора страны используется
список Страна.




         Рисунок 3.2 – Диалоговое окно программы примера 2 с использованием оператора case

     Дайте название формы в окне инспектора свойств, введите четыре метки, из которых три будут
предназначены для поясняющих надписей, а четвертая – для вывода результата счета.
     Для выбора названия страны используется список  компонент ListBox. Значок компонента ListBox
находится на вкладке Standard (см. рисунок 1.2). Добавляется список к форме приложения точно так же,
как и другие компоненты, например, командная кнопка или поле редактирования. В таблице 3.3
приведены свойства компонента ListBox.

Таблица 3.3 – Свойства компонента ListBox
    Свойство                                      Определяет
 Name            Имя компонента. В программе используется для доступа к свойствам компонента
 Items           Элементы списка
 Itemindex       Номер выбранного элемента списка. Номер первого элемента списка равен нулю
 Left            Расстояние от левой границы списка до левой границы формы
 Top             Расстояние от верхней границы списка до верхней границы формы
 Height          Высоту поля списка
 Width           Ширину поля списка
 Font            Шрифт, используемый для отображения элементов списка
 Parent-Font     Признак наследования свойств шрифта родительской формы

     Наибольший интерес представляют свойства Items и Itemindex. Свойство Items содержит элементы
списка.
     Свойство Itemindex задает номер выбранного элемента списка. Если ни один из элементов не выбран,
то значение свойства равно минус единице.
     Список может быть сформирован одним из двух способов: во время создания формы и во время
работы программы. Для формирования списка во время создания формы надо в окне Object Inspector
выбрать свойство Items и щелкнуть на кнопке запуска редактора списка строк.
     В открывшемся диалоговом окне String List Editor (рисунок 3.3) нужно ввести список, набирая
каждый элемент списка в отдельной строке. После ввода очередного элемента списка для перехода к
новой строке необходимо нажать клавишу <Enter>. После ввода последнего элемента клавишу <Enter>
нажимать не надо. Завершив ввод списка, следует щелкнуть на кнопке ОК.

42
                                  Рисунок 3.3 – Редактор списка

     В таблице 3.4 перечислены компоненты формы приложения, а в таблице 3.5 приведены значения
свойств компонентов.

Таблица 3.4 – Компоненты формы
       Компонент                                 Назначение
 ListBoxl             Для выбора страны, для которой надо выполнить пересчет
 Editl                Для ввода веса в фунтах
 Label1, Label2,      Для вывода пояснительного текста о назначении полей ввода
 Label3
 Label4               Для вывода результата пересчета
 Button1              Для активизации процедуры пересчета веса из фунтов в килограммы
 Button2              Для процедуры завершения работы программы

Таблица 3.5 – Значения свойств компонентов
        Свойство                                   Значение
 Form1.Caption          Пример оператора «выбор»
 Edit1. Text
                        Программа пересчета фунтов в килограммы для различных стран.
 Label1.Caption
                        Выберите страну и нажмите на кнопку Вычислить
 Label2.Caption         Страна
 Label3.Caption         Фунтов
 Button1.Caption        Вычислить
 Button2.Caption        Завершить

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

    Листинг 3.2 Код процедуры пересчета массы из фунтов в килограммы

    procedure TForm1.FormCreate(Sender: TObject);
    begin
          ListBox1.items.add('Россия');// список формируется во время работы
     программы
          ListBox1.items.add('Англия');
          ListBox1.items.add('Австрия');
          ListBox1.items.add('Германия');
          ListBox1.items.add ('Дания');
          ListBox1.items.add('Исландия');
          ListBox1.items.add ('Нидерланды');
          ListBox1.items.add ('Италия');
          ListBox1.itemindex:=0;
    end;

                                                                                            43
      procedure TForm1.Button1Click(Sender: TObject);
      var
           funt:real; // масса в фунтах
           kg:real; // масса в килограммах
           k:real; // коэффициент пересчета
      begin
           case ListBox1.Itemindex of
                   0: k:=0.4095; // Россия
                   1: k:=0.453592; // Англия
                   2: k:=0.56001; // Австрия
                   3..5,7: k:=0.5; // Германия, Дания, Исландия, Нидерланды
                   6: k:=0.31762; // Италия
           end;
           funt:=StrToFloat(Edit1.Text);
           kg:=k*funt;
           label4.Сaption:=Edit1.Text+ ' ф. — это '
           + FloatToStrF(kg,ffFixed, 6,3) + 'кг.';
      end;
      procedure TForm1.Button2Click(Sender: TObject);
          begin
           Form1.Close;
          end;

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

     Пример 3. При выводе числовой информации с поясняющим текстом возникает проблема
согласования выводимого значения и окончания поясняющего текста.
     Например, в зависимости от числового значения поясняющий текст к денежной величине может
быть: «рубль», «рублей» или «рубля» (123 рубля, 120 рублей, 121 рубль). Очевидно, что окончание
поясняющего слова определяется последней цифрой числа, что отражено в таблице 3.6.

Таблица 3.6 – Зависимость окончания текста от последней цифры числа
        Цифра           Поясняющий текст
 0, 5, 6, 7, 8, 9   рублей
 1                  рубль
 2, 3, 4            рубля

     Приведенное в таблице правило имеет исключение для чисел, оканчивающихся на 11, 12, 13, 14. Для
них поясняющий текст должен быть «рублей». Диалоговое окно программы приведено на рисунке 3.4.




                             Рисунок 3.4 – Окно диалога для примера 3


     В данном примере для формы понадобятся две метки и одно окно редактирования. В первой метке
размещается текст «Введите целое число и нажмите клавишу Enter». Во второй метке будет выводиться

44
результат работы программы. В окне редактирования – исходные данные. Для данного приложения
потребуется написать лишь одну процедуру обработки события OnKeyPress (нажатие клавиши). Для
этого в окне инспектора событий перейдите на вкладку Events (события) и в левом столбце найдите
название события – OnKeyPress. После двойного щелчка в правом поле данной строки автоматически
появляется окно кода программы, где можно вводить последовательные инструкции.

Листинг 3.3 Процедура формирования поясняющего текста

    procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);
        var
        n: integer; // вводимое целое число
        r: integer; // остаток от деления n на 10
        text: string[10]; // формируемый текст к числу
          begin
              if Key = chr(VK_RETURN) then
             begin
                n:= StrToInt(Edit1.Text); // считываются символы из окна
         редактирования и преобразуются в число
                if (n >= 11) and (n <= 14) then
                text:=' рублей' else
                 begin
                    r:= n mod 10;
                    case r of
                            1: text:=' рубль';
                         2..4: text:=' рубля'
                         else text:=' рублей';
                    end;
               end;
                   Label2.Caption := IntToStr(n)+ text; // вывод числа и
              поясняющего текста в окно редактирования
              end;
            end;

     Пример 4. Создадим приложение, которое вычисляет дату следующего дня, используя
сегодняшнюю дату, представленную тремя переменными: day (день), month (месяц) и year (год).




                              Рисунок 3.5 – Окно диалога для примера 4

     В данном примере необходимо написать одну процедуру обработки события OnClick в поле
редактирования Edit3 (Edit3Click). В программе демонстрируется работа оператора выбора.
     Сначала с помощью инструкции саsе проверяется, является ли текущий день последним днем
месяца. В случае, когда день является последним в месяце, логической переменной last присваивается
значение «истина». Если текущий месяц  февраль и если текущее число  28, то дополнительно
выполняется проверка, является ли год високосным. Для этого вычисляется остаток от деления года на 4.
Если остаток равен нулю, то год високосный, и число 28 не является последним днем месяца. Проверяется
также условие: если введено число 29, а год невисокосный, то выводится сообщение «В этом году в
феврале 28 дней».

                                                                                                  45
     Если выясняется, что текущий день  последний день месяца, то следующее число  первое. Затем
проверяется, не является ли текущий месяц декабрем. Если нет, то увеличивается номер месяца, а если да,
то увеличивается номер года, а номеру месяца присваивается значение 1.

Листинг 3.4 Процедура вычисления даты следующего дня

      procedure TForm1.Edit3Click(Sender: TObject);
         Label 1;
         var
         day: integer; // день
         month: integer; // месяц
         year: integer; // год
         last: boolean; // если день — последний день месяца, то last = True
         r: integer; // если год невисокосный, то остаток от деления year на 4
     не равен нулю
            begin
               day:=StrToInt(Edit1.Text);
               month:=StrToInt(Edit2.Text);
               year:=StrToInt(Edit3.Text);
               last:= False; // пусть день — не последний день месяца
               case month of
               4,6,9,11: if day = 30 then last:= True;
               2: if day = 28 then
                        begin
                         r:= year mod 4; if r <> 0 then last:= True;
                       end
                           else
                          if day=29 then
                           begin
                           Label5.Caption := 'В этом году в феврале 28 дней';
                            goto 1;
                           end;
               1,3,5,8,10,12:if day=31 then last:= True;
              end;
                if last then
                       begin //последний день месяца
                         day:= 1;
                         if month =12 then
                              begin // последний месяц
                                  month:= 1;
                                  year:= year + 1;
                              end
                         else month:= month + 1;
                       end
               else day:= day + 1;
               // переменные day, month и year содержат дату завтрашнего дня
               Label5.Caption := 'Завтра будет '+IntToStr(day)+ '.
              '+IntToStr(month)+'. '+IntToStr(year);
           1:end;

     3.4 Индивидуальные задания

      По указанию преподавателя выберите номер индивидуального задания из нижеприведенного списка.
Создайте форму, напишите текст программы в соответствии с полученным заданием.
      1. Вычислить r = max(min(f(x), у), z) при заданных x, y, z. В качестве f(x) использовать по выбору:
sh(х), cos(x), exp(x).
      2. Вывести на экран 1 или 0 в зависимости от того, имеют три заданных числа одинаковую четность
или нет.
      3. Известно, что из четырех чисел а1, а2, а3 и а4 одно отлично от трex других, равных между собой.
Присвоить номер этого числа переменной n.
      4. Вывести на экран 1 или 0 в зависимости от того, равна ли сумма двух первых цифр заданного
четырехзначного числа сумме двух его последних цифр.



46
     5. Вывести на экран 1 или 0 в зависимости от того, равен ли квадрат этого трехзначного числа кубу
суммы цифр этого числа.
     6. Вывести на экран 1 или 0 в зависимости от того, есть ли среди цифр трехзначного числа
одинаковые.
     7. Пусть k  целое от 1 до 365. Присвоить целой переменной n значение 1, 2, 3,...,6 или 7 в
зависимости от того, на какой день недели (понедельник, вторник, ..., суббота или воскресенье)
приходится k-й день невисокосного года, в котором 1 января  понедельник.
     8. По номеру n (n>0) некоторого года определить c  номер его столетия (учесть, что, к примеру,
началом XX столетия был 1901, а не 1900 год!).
     9. Значения переменных а, b и c поменять местами так, чтобы оказалось а<=b<=с.
    10. Дано целое k от 1 до 180. Определить, какая цифра находится в k-й позиции последовательности
10111213...9899 , в которой выписаны подряд все двузначные числа.
    11. Дано натуральное k. Определить k-ю цифру в последовательности 110100100010000100000..., в
которой выписаны подряд степени 10.
    12. В старояпонском календаре был принят 60-летний цикл, состоявший из пяти 12-летних
подциклов. Подциклы обозначались названиями цвета: green(зеленый), red (красный), yellow (желтый),
white (белый) и black (черный). Внутри каждого подцикла годы носили названия животных: крысы,
коровы, тигра, зайца, дракона, змеи, лошади, овцы, обезьяны, курицы, собаки и свиньи (1984 год – год
зеленой крысы  был началом очередного цикла). Разработать программу, которая вводит номер
некоторого года нашей эры и выводит его название по старояпонскому календарю.
    13. Если сумма трех попарно различных действительных чисел х, у, z меньше единицы, то
наименьшее из этих трех чисел заменить полусуммой двух, в противном случае – заменить меньшее из х и
у полусуммой двух оставшихся значений.
    14. Для целого числа k от 1 до 99 вывести фразу «мне k лет», учитывая при этом, что при некоторых
значениях k слово «лет» надо заменить на слово «год» или «года».
    15. Для натурального числа k вывести фразу «мы выпили k бутылок пива», согласуя окончание слова
«бутылка» с числом k.




                                                                                                   47
               4 ИСПОЛЬЗОВАНИЕ СРЕДСТВ ОТЛАДКИ ПРОГРАММ В DELPHI.
                   ПРОГРАММИРОВАНИЕ ЦИКЛИЧЕСКИХ АЛГОРИТМОВ

     4.1 Отладка программы

     Практически в каждой вновь написанной программе после запуска обнаруживаются ошибки.
     Ошибки первого уровня (ошибки компиляции) связаны с неправильной записью операторов
(орфографические, синтаксические). При обнаружении ошибок компилятор Delphi останавливается
напротив первого оператора, где обнаружена ошибка. В нижней части экрана появляется текстовое окно,
содержащее сведения обо всех ошибках, найденных в проекте. Каждая строка этого окна содержит имя
файла, в котором найдена ошибка, номер строки с ошибкой и характер ошибки. Для быстрого перехода к
интересующей ошибке необходимо дважды щелкнуть на строке с ее описанием. Для получения более
полной информации о характере ошибки необходимо обратится к HELP нажатием клавиши F1. Одна
ошибка может повлечь за собой другие, которые исчезнут при ее исправлении. Поэтому следует
исправлять ошибки последовательно, сверху вниз и после исправления каждой ошибки компилировать
программу снова.
     Ошибки второго уровня (ошибки выполнения) связаны с ошибками выбранного алгоритма решения
или с неправильной программной реализацией алгоритма. Эти ошибки проявляются в том, что результат
расчета оказывается неверным, либо происходит переполнение, деление на ноль и др. Поэтому перед
использованием отлаженной программы ее надо протестировать, т.е. сделать просчеты при таких
комбинациях исходных данных, для которых заранее известен результат. Если тестовые расчеты
указывают на ошибку, то для ее поиска следует использовать встроенные средства отладки среды Delphi.
     В простейшем случае для локализации места ошибки рекомендуется поступать следующим образом.
В окне кода программы установить курсор в строке перед подозрительным участком и нажать клавишу F4
(выполнение до курсора). Выполнение программы будет остановлено на строке, содержащей курсор.
Теперь можно увидеть, чему равно значение интересующих переменных. Для этого надо поместить на
нужную переменную курсор (на экране будет высвечено ее значение) либо нажать Ctrl-F7 и в
появившемся диалоговом окне указать интересующую переменную (с помощью данного окна можно
также изменить значение переменной во время выполнения программы). Нажимая клавишу F7 (пошаговое
выполнение), можно построчно выполнять программу, контролируя изменение тех или иных переменных
и правильность вычислений. Если курсор находится внутри цикла, то нажатием клавиши F4 расчет
останавливается после одного выполнения тела цикла. Для продолжения расчетов следует нажать <Run>
меню Run.

     4.2 Циклы

     Алгоритмы решения многих задач являются циклическими, т. е. для достижения результата
определенная последовательность действий должна быть выполнена несколько раз.
     Алгоритм, содержащий последовательность операций (группу инструкций), которая должна быть
выполнена несколько раз, называется циклическим, а сама последовательность операций именуется
циклом.
     Различают три типа операторов цикла: цикл со счетчиком (for), цикл с предусловием (while) и цикл с
постусловием (repeat).

     4.2.1 Инструкция for

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

     for <счетчик>:= <нач_знач> to <кон_знач> do
     begin
     // здесь инструкции, которые надо выполнить несколько раз
     end;
     где:
      счетчик – переменная-счетчик числа повторений инструкций цикла;
      нач_знач – выражение, определяющее начальное значение счетчика циклов;
      кон_знач – выражение, определяющее конечное значение счетчика циклов.
     Переменная-счетчик, выражения нач_знач и кон_знач должны быть целого типа. Если в инструкции
for вместо слова to записать downto, то после очередного выполнения инструкций тела цикла значение
счетчика будет не увеличиваться, а уменьшаться.
     Количество повторений инструкций цикла можно вычислить по формуле: (кон_знач  нач_знач + 1).


48
     Примеры записей оператора цикла:

     for i:=l to 10 do
     begin
     label1.caption:=label1.caption + '*'; // добавление в поле метки label1
                                              знака «*»
     end;
     for i: =1 to n do s := s+i; // увеличение значения переменной на
                                    величину i.

    Примечание – Если между begin и end находится только одна инструкция, то слова begin и end
можно не писать.
    Переменную-счетчик можно использовать внутри цикла (но ни в коем случае не изменять).
Например, в результате выполнения инструкций

     tab1: = ''; // переменная tab1 – строкового типа
     for i:=1 to 5 do
     begin
     tab1:=tab1+IntToStr(i)+' '+IntToStr(i*i)+chr(13);// увеличение
     содержимого строки на величину i, i2 и перевод курсора на новую строку
     end;

переменная tab1 будет содержать изображения таблицы квадратов чисел от 1 до 5. Chr(13) – код клавиши
<Enter>  перевода курсора на новую строку.

     4.2.2 Инструкция while

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

     while условие do
     begin
     // здесь инструкции, которые надо выполнить несколько раз
     end;

     где условие  выражение логического типа, определяющее условие выполнения инструкций цикла.
     Инструкция while выполняется следующим образом:
      сначала вычисляется значение выражения «условие»;
      если значение выражения «условие» равно False (условие не выполняется), то на этом выполнение
инструкции while завершается;
      если значение выражения «условие» равно True (условие выполняется), то выполняются
расположенные между begin и end инструкции тела цикла. После этого снова проверяется выполнение
условия. Если условие выполняется, то инструкции цикла выполняются еще раз. И так до тех пор, пока
условие не станет ложным (False).
     Для того чтобы инструкции цикла while, которые находятся между begin и end, были выполнены
хотя бы один раз, необходимо, чтобы перед выполнением инструкции while значение выражения
«условие» было истинно.
     Для того чтобы цикл завершился, нужно, чтобы последовательность инструкций между begin и end
влияла на значение выражения «условие» (изменяла значения переменных, входящих в выражение
«условие»).

     4.2.3 Инструкция repeat

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

     repeat
     // инструкции
     until условие;


                                                                                                   49
     где условие  выражение логического типа, определяющее условие завершения цикла.
     Инструкция repeat выполняется следующим образом:
      сначала выполняются находящиеся между repeat и until инструкции тела цикла;
      затем вычисляется значение выражения «условие» – если условие ложно (значение выражения
«условие» равно False), то инструкции тела цикла выполняются еще раз;
      если условие истинно (значение выражения «условие» равно True), то выполнение цикла
прекращается.
     Таким образом, инструкции цикла, находящиеся между repeat и unti1, выполняются до тех пор, пока
условие ложно (значение выражения «условие» равно False).
     Примечание – Инструкции цикла, находящиеся между repeat и until, выполняются как минимум
один раз. Для того чтобы цикл завершился, необходимо, чтобы инструкции цикла, располагающиеся
между repeat и until, изменяли значения переменных, входящих в выражение «условие».

      4.3 Лабораторная работа №4. Программирование циклических алгоритмов
     Цель работы: научиться создавать приложения в среде Delphi с использованием циклических
алгоритмов и средств отладки программ в Delphi.

      Пример 1. Рассмотрим программу, которая вычисляет сумму первых десяти элементов ряда:
     1 1                                                                       1
1       (значение i-го элемента ряда связано с его номером формулой          ). Диалоговое окно
     2 3                                                                       i
программы (рисунок 4.1) должно содержать два компонента полей меток (Label1, Label2) для
поясняющего текста к вводимым данным и вывода результатов, один компонент – поле редактирования 
для ввода числа n (количество элементов ряда), а также командную кнопку (Button1).




                              Рисунок 4.1 – Диалоговое окно примера 1

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

      Листинг 4.1 Код процедуры суммы числового ряда

      procedure TForm1.Button1Click(Sender: TObject);
      var i, n: integer;
           a, S: real;
           tab1: string;
      begin
           n:=StrToInt(Edit1.Text);// преобразование содержимого поля Edit1 в
       целое число
           tab1:=tab1+'i'+'   a    '+chr(13);// формирование строки – «шапки»
       таблицы
             S:=0;
            for i:=1 to n do
               begin
           a:=1/i;S:=S+a;




50
         tab1:=tab1+ IntToStr(i) + ' '+
     FloatToStrF(a,ffFixed,8,4)+chr(13);//i-тая строка вывода результата –
     номер и значение слагаемого
             end;
         tab1:=tab1+'S='+ FloatToStrF(S,ffFixed,8,4);
          Label1.Caption:=tab1;// Вывод строки в поле метки Label1
    end;




                 Рисунок 4.2 – Результат работы программы вычисления суммы ряда

     Пример 2. Рассмотрим программу, которая вычисляет значение числа  с точностью, задаваемой
пользователем во время работы программы. В основе алгоритма вычисления лежит тот факт, что сумма
бесконечного знакопеременного ряда 1 - 1/3 + 1/5 - 1/7 + 1/9 + ... приближается к значению /4 при
достаточно большом количестве членов ряда.
     Каждый член ряда с номером n вычисляется по формуле     1    и умножается на минус один, если n
                                                           2n  1
 четное (определить, является ли n четным, можно проверкой остатка от деления n на 2 или функцией
odd). Вычисление заканчивается тогда, когда значение очередного члена ряда по модулю становится
меньше, чем заданная точность вычисления.
     Вид диалогового окна программы во время ее работы приведен на рисунке 4.3. Пользователь вводит
точность вычисления в поле ввода (Edit1). После щелчка на командной кнопке Вычислить (Buttonl)
программа вычисляет значение числа  и выводит результат в поле метки (Label1).
     Текст процедуры приведен в листинге 4.2. Как и в предыдущих примерах, основную работу
выполняет процедура обработки события OnClick.




                    Рисунок 4.3 – Диалоговое окно программы вычисления числа 




                                                                                                 51
     Листинг 4.2 Код процедуры для примера 2

     procedure TForm1.Button1Click(Sender: Tobject);
      var
           pi: real; // вычисляемое значение Пи
           t: real; // точность вычисления
           n: integer; // номер члена ряда
           elem: real; // значение элемента ряда
     begin
        pi:= 0;
        n:= 1;
        t:= StrToFloat(edit1.text) ;
          elem:= 1; // значение элемента ряда при n=1, чтобы начать цикл
          while elem >= t do
              begin
                 elem:= 1/(2*n – 1);
                if n mod 2=0
                 then pi:= pi – elem
                else
                 pi:= pi + elem; n:= n + 1;
              end;
          pi:=pi*4;
          label2.caption:= ’Пи равно ’+ FloatToStr(pi) + #13
          + ’Просуммировано ’+IntTostr(n)+ ’ членов ряда ’;
     end;

     Пример 3. В качестве примера использования инструкции repeat рассмотрим программу, которая
проверяет, является ли введенное пользователем число простым (как известно, число называется простым,
если оно делится только на единицу и само на себя). Например, число 21  составное (делится на 3), а
число 17  простое (делится только на 1 и на 17).
     Проверить, является ли число n простым, можно делением числа n на два, на три и т. д. до n и
проверкой остатка после каждого деления. Если после очередного деления остаток равен нулю, то это
означает, что найдено число, на которое n делится без остатка. Сравнив n и число, на которое n
разделилось без остатка, можно определить, является ли n простым числом.
     Форма приложения «Простое число» изображена на рисунке 4.4, а в листинге 4.3 приведен текст
процедуры.




                     Рисунок 4.4 – Диалоговое окно программы «Простое число»

     Листинг 4.3 Код процедуры примера 3

     procedure TForm1.Button1Click(Sender: TObject);
        var
            n: integer; // проверяемое число
            r, d: integer; // остаток от деления n на делитель d
     begin
        n:=StrToInt(Edit1.text);// число считывается из окна редактирования
        d:= 2; // сначала будем делить на 2

52
       repeat
       r:= n mod d;
       if r <> 0 // n не разделилось нацело на d
       then d:= d + 1;
       until r = 0; // найдено число, на которое разделилось n без остатка
       label2.caption:=Edit1.text;
       if d = n then label2.caption:=label2.caption + ' — простое число.'
         else label2.caption:=label2.caption + ' — составное число.';
    end;

     Пример 4. В этом примере использована задача примера 3, но с проверкой числа n. В программе
инструкция goto используется для завершения процедуры в том случае, если пользователь введет
неверные данные. В этом случае появляется окно сообщения об ошибке ввода (рисунок 4.5). Вот фрагмент
программы вызова диалогового окна (MessageDlg):

    if n <= 0 then begin
        MessageDlg('Число должно быть больше нуля.', mtError, [mbOk] , 0) ;
    Editl.text:= "; //Очищение окна редактора
      goto bye;
           end;




                           Рисунок 4.5 – Окно сообщения об ошибке ввода


    4.4 Индивидуальные задания

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

    1. Для заданного натурального числа n определить количество цифр в числе и сумму всех его цифр.
    2. Вывести на печать таблицу n значений функции y  a * x 2  b * x  c при изменении x от x1 до x2 с

шагом h  x2  x1  . Исходные данные: a, b, c, x1, x2, n.
           n  1
    3. Для заданных n и m вычислить число сочетаний по формуле:

                                                              n!      ,
                                                   Cn 
                                                    m

                                                          m!n  m !
где n!=1*2*3*…*n; n>=m>0.
     4. Для заданного n вычислить значение выражения
                                                1 1      1         1      .
                                           b  1   2  3  ...  n      
                                                  2 2   2         2       
    5. Вычислить приближенно значение суммы бесконечного ряда с точностью до =0,0001:
                                                                                         k
                                                                    k                  
                                               2          3
                                       n   n 
                                                        ...  1 
                                   n                                          n
                        S  1              
                                 2 *3  3* 4   4 *5                k  1* k  2   ...
                                                                                        
                                                                                       
     Примечание – Считать, что требуемая точность достигнута, если очередное слагаемое оказалось по
модулю меньше, чем .
     6. Вычислить сумму бесконечного ряда
                                                        2n
                                          S    1
                                                     n x

                                              n 0     2n !
с точностью =0,001.
     Примечание (см. задание 5).


                                                                                                      53
     7. Вычислить сумму бесконечного ряда
                                                                  S 
                                                                          1i
                                                                         i  1!
с точностью =0,0001.
     Примечание (см. задание 5).
     8. Дано х=1,55 и =0,0183. Вычислить и вывести на экран таблицу значений функции
                                                                         x
                                                                   y       ,
                                                                         k!
больших , если k=1, 2, 3,….
     9.   Вычислить значение функции y                     k       для k=1, 2, …. Вычисления производить до тех пор,
                                                         x  y k 1
                                                              k


пока y>=z. Исходные данные: x, y, z; x>1, y>1.
     10. Вычислить сумму бесконечного ряда
                                   x 1      
                                                       1             1   1  1    
                          S  ln         2                       2  3  5  
                                   x 1    i  0 2i  1x
                                                           2 i 1
                                                                      x 3x 5x    
с точностью =0,0001 и при х>1.
     Примечание (см. задание 5).
     11. Вычислить сумму бесконечного ряда
                                               
                                                       xi         x2 x3 x4
                                   S  ex               1 x         
                                              i 0     i!         2! 3! 4!
с точностью =0,0001 и при х>1.
     Примечание (см. задание 5).
     12. Вычислить сумму бесконечного ряда
                                          1 x      
                                                        x 2i 1         x3 x5    
                                 S  ln         2              2 x 
                                                                              
                                                                                  
                                          1 x    i  0 2i  1          3   5    
с точностью =0,0001 и   x  1.
     Примечание (см. задание 5).
     13. Вычислить сумму бесконечного ряда

                         S  arctgx 
                                          
                                              
                                                
                                                         1i 1            
                                                                                    
                                                                                        
                                                                                            1
                                                                                              
                                                                                                1
                                                                                                  
                                                                                                    1
                                                                                                         
                                               i  0 2i  1x
                                                                2i 1
                                          2                                         2       x 3x 3 5 x 5
с точностью =0,0001 и х>1.
     Примечание (см. задание 5).
     14. Вычислить сумму бесконечного ряда
                                                        
                                                              x 2i 1     x3 x5 x7
                                 S  artg ( x)                      x         
                                                       i 0   2i  1      3   5   7
с точностью =0,0001 и x  1 .
     Примечание (см. задание 5).
     15. Вычислить сумму бесконечного ряда
                                                   
                                                                   1                1   1   1
                               S  artg ( x)                                                
                                                i  0 2i  1x
                                                                2 i 1
                                                                                    x 3x 3 5 x 5
с точностью =0,0001 и   x  1.
     Примечание (см. задание 5).




54
                5 ИСПОЛЬЗОВАНИЕ КОМПОНЕНТА STRINGGRID. МАССИВЫ

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

    5.1 Объявление массива

     Массив, как и любая переменная программы, перед использованием должен быть объявлен в разделе
объявления переменных. В общем виде инструкция объявления массива выглядит следующим образом:
     имя: array [нижний_индекс. .верхний_индекс] of тип;
     где:
      имя  имя массива;
      array  зарезервированное слово языка Delphi, обозначающее, что объявляемое имя является
именем массива;
      нижний_индекс и верхний_индекс  целые константы, определяющие диапазон изменения
индекса элементов массива и, тем самым, количество элементов (размер) массива;
      тип  тип элементов массива.
     Примеры объявления массивов:

    temper:array[1..31] of real;
    коef:array[0. .2] of integer;
    name:array[1..30] of string[25];

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

    day [1]:= 'Понедельник';
    d:= koef[l]*koef[l]-4*koef[2]*koef[1];
    ShowMessage(name[n+1]);
    temper[i]:= StrToFloat(Edit1.text);

     Если массив не является локальным, т. е. объявлен не в процедуре обработки события, а в разделе
переменных модуля (unit), то одновременно с объявлением массива можно выполнить его
инициализацию, т. е. присвоить начальные значения элементам массива. Инструкция объявления массива
с одновременной его инициализацией в общем виде выглядит так:
     имя: array [нижний_индекс..верхний_индекс] of тип = (список);
     где список  разделенные запятыми значения элементов массива.
     Например:

    a: array[10] of integer = (0,0,0,0,0,0,0,0,0,0);
    day: array[1..7] of String[11]= ('Понедельник', 'Вторник', 'Среда',
   'Четверг', 'Пятница', 'Суббота', 'Воскресенье');

     Обратите внимание, что количество элементов списка инициализации должно соответствовать
размерности массива. Если это будет не так, то компилятор выведет сообщения об ошибке: Number of
elements differs from declaration (количество элементов не соответствует указанному в объявлении).
     При попытке инициализировать локальный массив компилятор выводит сообщение об ошибке:
Cannot initialize local variables (локальная переменная не может быть инициализирована). Локальный
массив можно инициализировать только во время работы программы, например, так:

    for i := 1 to 10 do
    a[i]:= 0;

    5.2 Операции с массивами

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



                                                                                                 55
     5.2.1 Вывод массива

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

     5.2.2 Ввод массива

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

     5.2.3 Использование компонента StringGrid

     Для ввода массива удобно использовать компонент StringGrid. Значок компонента StringGrid
находится на вкладке Additional (рисунок 5.1).




                                        StringGrid
           Вкладка Additional

                           Рисунок 5.1 – Главное окно. Вкладка Additional

     5.3 Многомерные массивы

     Исходные данные для решения многих задач можно представить в виде многомерных массивов:
двух, трех и большей размерности (размер массива ограничен лишь имеющейся памятью компьютера)
однотипных данных. Например, двумерный массив представляет собой матрицу (таблицу).
     В общем виде инструкция объявления двумерного массива выглядит так:
     имя: array[ НижняяГраница1..ВерхняяГраница1, НижняяГраница2..ВерхняяГраница2, …,
                 НижняяграницаN..ВерхняяграницаN] of тип
где:
      имя  имя массива;
      array  зарезервированное слово языка Delphi, указывающее, что объявляемый элемент данных
является массивом;
      НижняяГраница1, ВерхняяГраница1, НижняяГраницаN, ВерхняяГраницаN  граничные пары 
целые константы, определяющие диапазон изменения индексов и, следовательно, число элементов
массива;
      тип  тип элементов массива.
     Например:

     itog: array [1..12, 1..6] of integer;
     S: array[0..5,-2..8] of real;
     St: array[0..5,1..3,2..5] of string;

     Количество элементов двумерного массива можно вычислить по формуле:
                                   (ВГ1-НГ1+1)  (ВГ2-НГ2+1),
     где:
      ВГ1 и ВГ2  верхняя граница первого и второго индексов;
      НГ1 и НГ2  нижняя граница первого и второго индексов. Таким образом, массив itog состоит из
60 элементов типа integer, массив S – из 66 вещественных чисел, а трехмерный массив St – из 72
элементов строкового типа.

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

Таблица 5.1 – Свойства компонента StringGrid
        Свойство                                           Определяет
 Name                   Имя компонента. Используется в программе для доступа к свойствам
                        компонента
 ColCount               Количество колонок таблицы
 RowCount               Количество строк таблицы
 Cells                  Соответствующий таблице двумерный массив. Ячейка таблицы, находящаяся на
                        пересечении столбца номер col и строки номер row определяется элементом
                        cells [col, row]
 FixedCols              Количество зафиксированных слева колонок таблицы. Зафиксированные
                        колонки выделяются цветом и при горизонтальной прокрутке таблицы остаются
                        на месте. Данные в них не вводятся
 FixedRows              Количество зафиксированных сверху строк таблицы. Зафиксированные строки
                        выделяются цветом и при вертикальной прокрутке таблицы остаются на месте.
                        Данные в них не вводятся
 Options. goEditing     Признак допустимости редактирования содержимого ячеек таблицы. True 
                        редактирование разрешено, False  запрещено
 Options. goTab         Разрешает (True) или запрещает (False) использование клавиши <Таb> для
                        перемещения курсора в следующую ячейку таблицы
 Options. goAlways-     Признак нахождения компонента в режиме редактирования. Если значение
 ShowEditor             свойства False, то для того, чтобы в ячейке появился курсор, надо начать
                        набирать текст, нажать клавишу <F2> или сделать щелчок мышью
 DefaultColWidth        Ширину колонок таблицы
 DefaultRowHeight       Высоту строк таблицы
 GridLineWidth          Ширину линий, ограничивающих ячейки таблицы
 Left                   Расстояние от левой границы поля таблицы до левой границы формы
 Top                    Расстояние от верхней границы поля таблицы до верхней границы формы
 Height                 Высоту поля таблицы
 Width                  Ширину поля таблицы
 Font                   Шрифт, используемый для отображения содержимого ячеек таблицы
 ParentFont             Признак наследования характеристик шрифта формы

     При работе с таблицами (массивами) удобно использовать инструкцию for. Например, сумма
элементов второй строки массива itog будет накапливаться в цикле по j:

     sum:= 0;
     for j:= 1 to 12 do
     sum:= sum + itog[2,j];

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

     sum:=0;
     for i:= 1 to 6 do
     for j:= 1 to 12 do
     sum:= sum + itog[i,j];

     В приведенном фрагменте программы каждый раз, когда внутренний цикл (цикл по j) завершается,
во внешнем цикле значение i увеличивается на единицу, и внутренний цикл выполняется вновь. Таким
образом, к текущему значению переменной sum последовательно прибавляются значения элементов
массива itog: itog[1,1], itog[1,2], ..., itog[1,12], itog[2,1], itog[2,2], ..., itog[2,12] и т. д.
     При работе с массивами ввод и вывод информации на экран удобно организовать в виде таблиц.
Компонент TStringGrid предназначен для отображения информации в виде двумерной таблицы, каждая
ячейка которой представляет собой окно однострочного редактора (аналогично окну TEdit). Доступ к
информации осуществляется с помощью свойства
     Cells[АСоl, АRow: integer]: string
     где АСоl, ARow  индекс элемента двумерного массива.



                                                                                               57
     Свойства ColCount и RowCols устанавливают количество строк и столбцов в таблице, а свойства
FixedCols и FixedRows задают количество строк и столбцов фиксированной зоны. Фиксированная зона
выделена другим цветом, и в нее запрещается ввод информации с клавиатуры.

     5.4 Лабораторная работа №5. Программирование матричных операций
     Цель работы: научиться создавать приложения в среде Delphi с использованием матричных
операций и работать с компонентом StringGrid.

    Пример 1. В качестве примера на рисунке 5.2 приведено диалоговое окно приложения, которое
демонстрирует инициализацию и процесс вывода значений элементов массива в поле метки в виде списка.
Программа выводит значения элементов массива, заданных в модуле. Для того чтобы список элементов
выглядел действительно как список, свойству Label1.AutoSize нужно присвоить значение False. Текст
модуля приведен в листинге 5.1.




                    Рисунок 5.2 – Окно приложения для вывода элементов массива

     Листинг 5.1 Код процедуры примера 1

    unit Unit1;
    interface
    uses
      Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls,
Forms,
      Dialogs, StdCtrls;
    type
      TForm1 = class(TForm)
         Label1: TLabel;
         Button1: TButton;
         procedure Button1Click(Sender: TObject);
      private
         { Private declarations }
      public
         { Public declarations }
      end;

     var
        Form1: TForm1;
     implementation
     {$R *.dfm}
     const
     n=10; // инициализация значений n и А происходит в основном модуле
     A: array[1..n] of integer=(234,42,905,76,84,115,36,864,80,352);
     procedure TForm1.Button1Click(Sender: TObject);
       var
         st: string; // строка вывода
         i: integer; // счетчик числа элементов
       begin
           for i:=1 to N do // формирование строки вывода
           st:= st + IntToStr(i)+ ' '

58
           + IntToStr(A[i]) + #13;
          Label1.Caption:= st; // вывод строки в поле метки
        end;
     end.

     Пример 2. В качестве примера использования компонента StringGrid для ввода массива рассмотрим
программу, которая вычисляет среднее арифметическое значение элементов массива. Диалоговое окно
программы приведено на рисунке 5.3. Компонент StringGrid используется для ввода массива, компоненты
Label1 и Label2  для вывода пояснительного текста и результата расчета, Button1  для запуска процесса
расчета.




                              Рисунок 5.3 – Окно приложения для примера 2

     Добавляется компонент StringGrid в форму точно так же, как и другие компоненты. После
добавления компонента к форме нужно выполнить его настройку в инспекторе объектов в соответствии с
таблицей 5.2. Значения свойств Height и Width следует при помощи мыши установить такими, чтобы
размер компонента был равен размеру строки.

Таблица 5.2 – Значения свойств компонента StringGrid1
            Свойство                Значение                         Пояснения
 ColCount                          5              Устанавливаем количество колонок
 FixedCols                         0              Количество фиксируемых столбцов
 RowCount                          1              Устанавливаем количество строк
 DefaultRowHeight                  24             Высота ряда (авто)
 Height                            24             Высота таблицы
 DefaultColWidth                   64             Ширина ряда (авто)
 Width                             328            Ширина таблицы
 Options. goEditing                True           Разрешить ввод данных с клавиатуры
 Options. AlwaysShowEditing        True           Компонент находится в режиме редактирования.
                                                  При нажатии <Tab> курсор переходит в соседнюю
 Options.goTabs                    True
                                                  ячейку

    Описание массива носит локальный характер (в пределах одной процедуры), поэтому ввод данных
может происходить только в процессе выполнения процедуры. В листинге 5.2 приводится текст этой
процедуры.

     Листинг 5.2 Код процедуры примера 2

     procedure TForm1.Button1Click(Sender: TObject);
     var
     a: array[1..5] of integer; // массив
     summ: integer; // сумма элементов
     sr: real; // среднее значение
     i: integer; // счетчик
         begin // ввод массива
            // считаем, что если ячейка пустая, то соответствующий
               ей элемент равен нулю

                                                                                                    59
           for i:= 1 to 5 do
           if Length(StringGrid1.Cells[i-1, 0]) <>0 // если длина ячейки
       отлична от нуля
           then a[i]:= StrToInt(StringGrid1.Cells[i-1,0]) // то считываем
       текст, преобразуя его в число
           else a[i]:= 0;
             // обработка массива
           summ:= 0;
           for i :=1 to 5 do
           summ:= summ + a[i]; sr:= summ/5;
           // вывод результата в поле метки
           Label2.Caption:= 'Сумма чисел: ' + IntToStr(summ)
           + #13+ 'Среднее арифметическое: ' + FloatToStr(sr);
        end;

     Пример 3. В качестве примера работы с двумерными массивами рассмотрим программу умножения
квадратной матрицы на вектор-столбец: Y=A*B. В результате получим вектор Y, элементы которого
вычисляются по формуле:
                                                N
                                          Yi   Ai , j  Bi .
                                                j 1

     Значения N будем задавать как глобальную константу, A и B  в компонент TStringGrid. Результат
после нажатия кнопки типа TButton выведем в компонент TStringGrid. Панель диалога приведена на
рисунке 5.4. Для установки компонентов TStringGrid на форму необходимо на странице Additional
главного окна щелкнуть мышью по пиктограмме StringGrid (см. рисунок 5.2) и расположить их на форме.
Свойства компонентов StringGrid указаны в таблице 5.3. Кроме того, разместим на форме командную
кнопку Button1 с надписью «Вычислить».
     После подготовки формы напишем программу вычисления вектора Y. В программе участвуют две
процедуры. Процедура TForm1.FormCreate выполняет подготовительные функции: заполняет
поясняющими надписями фиксированные столбцы и строки таблиц. Процедура TForm1.Button1Click
описывает действия по вычислению нового вектора Y.




                               Рисунок 5.4 – Окно диалога примера 3




60
Таблица 5.3 – Свойства компонентов StringGrid1, StringGrid2 и StringGrid3

                                           Значения
           Свойство                                                            Пояснения
                              StringGrid1 StringGrid2 StringGrid3
  ColCount                         4           4            4               Количество колонок
  RowCount                         4           2            2                Количество строк
                                                                        Количество фиксируемых
  FixedCols                        1           1            1
                                                                               столбцов
  FixedRows                        1           1            1        Количество фиксируемых строк
  DefaultRowHeight                 20         20           20                  Высота ряда
  DefaultColWidth                  50         50           50                  Ширина ряда

  Height                           89         49           49                Высота таблицы
  Width                           209         209          209              Ширина таблицы
                                                                        Разрешить ввод данных с
  Options.goEditing               True        True        False
                                                                              клавиатуры
                                                                     Компонент находится в режиме
  Options.AlwaysShowEditing       True        True        False
                                                                            редактирования.
                                                                       При нажатии <Tab> курсор
  Options.goTabs                  True        True        False
                                                                      переходит в соседнюю ячейку

     Листинг 5.3 Текст процедуры умножения матриц

     procedure TForm1.FormCreate(Sender: TObject);
       var i: integer;
           begin
               {ввод в левую верхнюю ячейки таблицы названия массива}
               StringGrid1.Cells[0,0]:='Массив À:';
               StringGrid2.Cells[0,0]:='Массив B:';
               StringGrid3.Cells[0,0]:='Массив Y:';
               {заполнение верхнего и левого столбцов поясняющими надписями}
               for i:=1 to n do begin
               StringGrid1.Cells[0,i]:=' i='+IntToStr(i);
                StringGrid1.Cells[i,0]:=' j='+IntToStr(i);
               StringGrid2.Cells[i,0]:=' j='+IntToStr(i);
                                 end;
           end;
     procedure TForm1.Button1Click(Sender: TObject);
         var s: real; i, j: integer;
              A: Mas2; // объявление двумерного массива
              B, Y: Mas1;
             begin
                 {заполнение массива А элементами из таблицы StirngGrid1}
                    for i:=1 to N do
                    for j:=1 to N do
                      A[i,j]:=StrToFloat(StringGrid1.Cells[j,i]);
                 {заполнение массива В элементами из таблицы StirngGrid2}
                    for i:=1 to N do
                    if length(StringGrid2.Cells[i,1])<>0 then
                       B[i]:=StrToFloat(StringGrid2.Cells[i,1])
                    else B[i]:=0;
                 {умножение массива A на массив B}
                    for i:=1 to n do begin
                        s:=0;
                    for j:=1 to n do s:=s+A[i,j]*B[j];
                        Y[i]:=s;
                 {вывод результата в таблицу StringGrid3}
                 StringGrid3.Cells[i,1]:=FloatToStrF(y[i],ffFixed,6,2);
                    end;
             end;

                                                                                                    61
      Результат работы программы умножения квадратной матрицы на вектор-столбец показан на рисун-
ке 5.5.




               Рисунок 5.5 – Результат работы программы умножения матрицы на вектор

     5.5 Индивидуальные задания

     Во всех заданиях по теме «Массивы» скалярные переменные вводить с помощью компонента TEdit с
соответствующим пояснением в виде компонента TLabel. Скалярный результат выводить в виде
компонента TLabel. Массивы представлять на форме в виде компонентов TStringGrid, в которых нулевой
столбец и нулевую строку использовать для отображения индексов массивов. Вычисления выполнять
после нажатия кнопки типа TButton.
     1. Задана матрица размером nm. Получить массив В, присвоив его k-му элементу значение 0, если
все элементы k-го столбца матрицы нулевые, и значение 1 в противном случае.
     2. Задана матрица размером nm. Получить массив В, присвоив его k-му элементу значение 1, если
элементы k-й строки матрицы упорядочены по убыванию, и значение 0 в противном случае.
     3. Задана матрица размером nm. Получить массив В, присвоив его k-му значение 1, если k-я строка
матрицы симметрична, и значение 0 в противном случае.
     4. Задана матрица размером nm. Определить k  количество «особых» элементов матрицы, считая
элемент «особым», если он больше суммы остальных элементов своего столбца.
     5. Задана матрица размером nm. Определить k  количество «особых» элементов в матрице, считая
элемент «особым», если в его строке слева от него находятся элементы, меньшие его, а справа  большие.
     6. Задана матрица размером nm (n=2, m=10). Начиная с первого столбца матрицы проверить знак
произведения двух элементов каждого столбца и печатать эти произведения, прекращая данный процесс
при выявлении отрицательного знака у произведения элементов.
     7. Задана матрица размером nm (n=2, m=10). Отпечатать среднее арифметическое двух элементов
каждого столбца, в котором модуль разности этих элементов меньше 0,01.
     8. Задана матрица размером nm (n=2, m=10). Печатать произведение двух элементов каждого
столбца, начиная с первого столбца и прекращая процесс рассмотрения столбцов, как только будет
выявлено равенство двух элементов в каком-либо столбце.
     9. Задана матрица размером nm (n=2, m=10. Первый элемент каждой строки представляет
абсциссу, а второй ординату одной из 10 точек. Отпечатать расстояния от начала координат для всех
точек, которые принадлежат кругу с радиусом R.
     10. Задана матрица размером nm (n=10, m=2). Отпечатать номер каждой ее строки, квадрат первого
элемента которой меньше второго элемента.
     11. Задана матрица размером nm (n=10, m=3). Содержание трех элементов каждой строки трактуется
как длины сторон одного из 10 треугольников. Последовательно рассматривая строки, печатать периметр
треугольника или -1: -1 – если треугольник построить нельзя.


62
     12. Задана матрица размером nm (n=10, m=3). Первый и второй элементы каждой строки
представляют абсциссу и ординату одного из 10 датчиков, измеряющих температуру поверхности, а
третий элемент  показание этого датчика. Найти среднее арифметическое показание тех датчиков,
температура которых не превышает 100 оС, отпечатать их координаты и координаты датчика с
максимальным показателем.
     13. Задана матрица размером nm (n=10, m=2). Первый элемент каждой строки является полярным
радиусом, а второй полярным углом одной из 10 точек Если полярный угол ни одной из точек не
превышает величины Р, то отпечатать координаты тех точек, полярный радиус которых меньше К (P и K
заданы). В противном случае печатать сообщение «Требуется поворот координат».
     14. Задана матрица размером nm (n=10, m=3). Содержание трех элементов каждой ее строки
трактуется как длины сторон одного из 10 треугольников. Если в каждой строке элементы таковы, что
сумма двух любых из них больше третьего, найти среднее арифметическое площадей треугольников.
     15. Задана матрица размером nm (n=2, m=10). Отпечатать каждый элемент первой строки, который
больше находящегося в одном столбце с ним элемента второй строки. При обнаружении равенства
просмотр прекратить.




                                                                                               63
                            6 ТИПОВЫЕ ОПЕРАЦИИ С МАССИВАМИ

     К типовым операциям с массивами относятся:
      вычисление суммы и произведения элементов массива;
      поиск минимального (максимального) элемента в массиве;
      поиск в массиве заданного элемента;
      сортировка массива.
     В данном разделе рассмотрим примеры программирования трех первых задач. Алгоритмы
сортировки массивов можно посмотреть в специальной литературе по программированию.

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

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

     6.2 Лабораторная работа №6. Программирование типовых операций с матрицами

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

     Пример 1. Пусть задан двумерный массив целых чисел. Найдем сумму всех элементов матрицы,
сумму элементов, стоящих на главной диагонали, произведение элементов, стоящих на побочной
диагонали, минимальный элемент и его координаты, а также координаты заданного образца. Размер
массива будем вводить в поле Edit1, образец – в поле Edit2, элементы массива – из компонента StringGrid.
Вывод скалярных переменных – в поле метки Label3. Метки Label1, Label2, Label4 нужны для
поясняющих надписей. Вид формы показан на рисунке 6.1. Свойства компонента StringGrid1 такие же, как
в таблице 5.3, за исключением количества строк и столбцов. Текст программы приведен в листинге 6.1.




                               Рисунок 6.1 – Вид окна диалога примера 1



64
   Листинг 6.1 Текст модуля обработки массива

    unit S_P;
    interface
    uses
      Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls,
Forms,
      Dialogs, StdCtrls, Grids;
    type
      TForm1 = class(TForm)
         Label1: TLabel;
         Edit1: TEdit;
         Label2: TLabel;
         StringGrid1: TStringGrid;
         Button1: TButton;
         Label3: TLabel;
         procedure Button1Click(Sender: TObject);
      private
         { Private declarations }
      public
         { Public declarations }
      end;
     const nmax=10; {размер массива заведомо большой}
     type     Mas=array[1..nmax,1..nmax]   of   real;  {объявлен   тип   массив-
глобальная переменная}
     var
      Form1: TForm1;
    implementation
    {$R *.dfm}
    procedure TForm1.Button1Click(Sender: TObject);
       var A: Mas;
             i,j,n,mini,minj,iobr,jobr,k: integer;
             S,Sg,PP,min,obr: integer;
             found: boolean;
             st: string;
          begin
            N:=StrToInt(Edit1.Text); // ввод размерности массива
            obr:= StrToInt(Edit2.text);
            found:= FALSE; // пусть нужного элемента в массиве нет
                  {задание числа строк и столбцов в массиве}
            StringGrid1.ColCount:=N+1;
            StringGrid1.RowCount:=N+1;
            StringGrid1.Cells[0,0]:='Массив А:';
                  {заполнение левого и верхнего столбцов поясняющими надписями}
            for i:=1 to n do begin
                 StringGrid1.Cells[0,i]:='i='+IntToStr(i);
                 StringGrid1.Cells[i,0]:='j='+IntToStr(i);
            end;
                  {заполнение массива А элементами из таблицы StirngGrid1};
            for i:=1 to n do
            for j:=1 to n do
                 A[i,j]:=StrToFloat(StringGrid1.Cells[j,i]);
                 S:=0;Sg:=0; PP:=1; k:=0; {инициализация сумм и произведения}
              min:=A[1,1]; mini:=1;minj:=1;
            for i:=1 to n do
            for j:=1 to n do
                begin
                   S:=S+A[i,j]; {накопление суммы всех элементов в двойном
               цикле}
                   Sg:=Sg+A[i,i]; {накопление суммы диагональных элементов}
                   if (i+j=n+1) then PP:=PP*A[i,j]; //если элемент стоит на
               побочной диагонали, то входит в произведение}
                  {поиск минимального элемента}
                   if A[i,j]<min then

                                                                              65
                        begin
                           min:= A[i,j]; mini:= i; minj:= j;
                      end;
              {сравнение с образцом}
              if (A[i,j]=obr) then
                    begin
                        found:= TRUE; iobr:= i;jobr:= j; k:= k+1;
                    end;
                 end;
              if found then St:='Последнее совпадение с образцом i='+
              IntToStr(iobr) + ' j='+IntToStr(jobr)+#13+'Всего совпадений
              k='+IntToStr(k)
              else St:='Совпадений с образцом нет.';
              {вывод результата}
              label3.Caption:=' S='+ FloatToStrF(S,ffFixed,6,2)+#13+
              'Sg='+FloatToStrF(Sg,ffFixed,6,2)+#13+
              'PP='+ FloatToStrF(PP,ffFixed,6,2)+#13+st;
              label3.Caption:=' Сумма элементов массива S='+ IntToStr(S)+#13+
              'Сумма элементов главной диагонали Sg='+IntToStr(Sg)+#13+
              'Произведение элементов побочной диагонали PP='+ IntToStr(PP)+#13+
              'Минимальный элемент min='+IntToStr(min)+#13+
              'Координаты минимального элемента i='+IntToStr(mini)+'
              j='+IntToStr(minj)+#13+st;
            end;
     end.

     6.3 Индивидуальные задания

      Во всех приведенных ниже заданиях скалярные переменные вводить с помощью компонента TEdit с
соответствующим пояснением в виде компонента TLabel. Скалярный результат выводить в виде
компонента TLabel. Массивы представлять на форме в виде компонентов TStringGrid, в которых нулевой
столбец и нулевую строку использовать для отображения индексов массивов. Вычисления выполнять
после нажатия кнопки типа TButton.
      1. Задана матрица размером nm. Получить массив В, присвоив его k-му элементу значение 0, если
все элементы k-го столбца матрицы нулевые, и значение 1 в противном случае.
      2. Задана матрица размером nm. Получить массив В, присвоив его k-му элементу значение 1, если
элементы k-й строки матрицы упорядочены по убыванию, и значение 0 в противном случае.
      3. Задана матрица размером nm. Получить массив В, присвоив его k-му элементу значение 1, если
k-я строка матрицы симметрична, и значение 0 в противном случае.
      4. Задана матрица размером nm. Определить k  количество «особых» элементов матрицы, считая
элемент «особым», если он больше суммы остальных элементов своего столбца.
      5. Задана матрица размером nm. Определить k  количество «особых» элементов в матрице, считая
элемент «особым», если в его строке слева от него находятся элементы, меньшие его, а справа - большие.
      6. Задан одномерный упорядоченный по возрастанию массив размером N. Определить k – заданный
образец и его индекс в ряду элементов массива.
      7. Отсортировать неупорядоченный одномерный массив размером N по убыванию. Определить, есть
ли в нем одинаковые элементы.
      8. В упорядоченном по возрастанию массиве размером N определить, есть ли повторяющиеся
элементы и количество каждого из повторений.
      9. Задана матрица размером nm. Найти наибольший элемент каждой строки и сформировать из них
новый вектор. Вывести результат.
    10. Задана матрица размером nm. Найти наибольший и наименьший элементы матрицы. Поменять
их местами. Вывести результат.
    11. Задана матрица размером nm. Найти сумму из наибольших элементов и произведение из
наименьших элементов каждой строки.
    12. Задана матрица размером nm. Найти суммы элементов, лежащих выше и ниже главной
диагонали.
    13. Получить матрицу размером nn, у которой все элементы главной диагонали и выше ее равны 1,
остальные – 0.
    14. Заполнить матрицу размером 7*7 целыми числами, начиная с 1, по спирали. Вывести результат.
    15. Задана матрица размером nn. В каждой строке найти наибольший элемент и поставить его на
главную диагональ. Вывести результат.




66
                        7 СИМВОЛЫ И СТРОКИ. КОМПОНЕНТ PANEL

     Компьютер может обрабатывать не только числовую информацию, но и символьную. Язык Delphi
оперирует с символьной информацией, которая может быть представлена как отдельными символами, так
и строками (поcледовательностью символов).

    7.1 Символы

      Для хранения и обработки символов используются переменные типа ansichar и widechar. Тип
ansichar представляет собой набор ANSI-символов, в котором каждый символ кодируется
восьмиразрядным двоичным числом (байтом). Тип widechar представляет собой набор символов в
кодировке Unicode, в которой каждый символ кодируется двумя байтами.
      Для обеспечения совместимости с предыдущими версиями поддерживается тип char, эквивалентный
ansichar.
      Значением переменной символьного типа может быть любой отображаемый символ:
       буква русского или латинского алфавитов;
       цифра;
       знак препинания,
       специальный символ, например, «новая строка»: #13.
      Переменная символьного типа должна быть объявлена в разделе объявления переменных.
Инструкция объявления символьной переменной в общем виде выглядит так:
      имя: char;
      где:
       имя  имя переменной символьного типа;
       char  ключевое слово обозначения символьного типа.
      Например:
      otv: char; ch: char;
      Как и любая переменная программы, переменная типа char может получить значение в результате
выполнения инструкции присваивания. Если переменная типа char получает значение в результате
выполнения операции присваивания, то справа от знака «:=» должно стоять выражение типа char,
например, переменная типа char или символьная константа  символ, заключенный в кавычки.
      В результате выполнения инструкций
      c1:= 'a';
      с2:= c1;
переменная c1 получает значение присваиванием значения константы, а переменная с2  присваиванием
значения переменной c1, если, конечно, переменные c1 и с2 являются переменными символьного типа.
      Переменную типа char можно сравнить с другой переменной типа char или с символьной константой.
Сравнение основано на том, что каждому символу поставлен в соответствие порядковый номер.
      '0'<'1'<..<'9'<..<'A'<'B'<..<'Z'<'a'<'b'<..<'z'
      Символам русского алфавита соответствуют числа большие, чем символам латинского алфавита, при
этом справедливо следующее:
      'А'<'Б'<'В'<..<'Ю'<'Я'<'а'<'б'<'в'<...<'э'<'ю'<'я'.
      В тексте программы вместо символа можно указать его код, поставив перед числом оператор #.
Например, вместо константы 'в' можно записать #193. Такой способ записи, как правило, используют для
записи служебных символов или символов, которые во время набора программы нельзя ввести с
клавиатуры. К примеру, часто используемый при записи сообщений символ "новая строка" записывается
так: #13.
      В программах обработки символьной информации часто используют функции chr и ord. Значением
функции chr является символ, код которого указан в качестве параметра. Например, в результате
выполнения инструкции prob:=chr(32) переменной prob будет присвоено значение «пробел». Функция ord
позволяет определить код символа, который передается ей в качестве параметра. Например, в результате
выполнения инструкции k:=ord('*') переменная k будет содержать число 42  код символа «*».

    7.2 Строки

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

                                                                                                 67
      Помимо перечисленных выше типов можно применять универсальный cтроковый тип string. Тип
string эквивалентен типу shortstring.
      Переменная строкового типа должна быть объявлена в разделе объявления переменных. Инструкция
объявления в общем виде выглядит так:
      bмя: string;
      или
      имя: string [длина];
      где:
       имя  имя переменной;
       string  ключевое слово обозначения строкового типа;
       длина  константа целого типа, которая задает максимально допустимую длину строки.
      Пример объявления переменных строкового типа:
      name: string[30];
      buff: string;
      Если в объявлении строковой переменной длина строки не указана, то ее длина задается равной 255
символам, т. е. объявления
      stroka: string [255]; stroka: string;
      эквивалентны.
      В тексте программы последовательность символов, являющаяся строкой (строковой константой),
заключается в одинарные кавычки. Например, чтобы присвоить строковой переменной p значение, нужно
записать:
      p:= 'Пароль'; или p:= '2001';
      Следует обратить внимание, что инструкция p:=2001, где цифры взяты без кавычек, неверная, т.к.
тип константы не соответствует типу переменной. Во время компиляции этой инструкции будет выведено
сообщение: incompatible types: 'Char' and 'Integer' (типы Char и Integer несовместимы).
      Используя операции =, <, >, <=, >= и <>, переменную типа string можно сравнить с другой
переменной типа string или со строковой константой. Строки сравниваются посимвольно, начиная с
первого символа. Если все символы сравниваемых строк одинаковые, то такие строки считаются равными.
Если в одинаковых позициях строк находятся разные символы, большей считается та строка, у которой в
этой позиции находится символ с большим кодом. В таблице 7.1 приведены примеры сравнения строк.

Таблица 7.1 – Сравнение строк
   Строка 1           Строка 2         Результат сравнения
 Иванов            Иванов            Строки равны
 Васильева         Васильев          Строка 1 больше строки 2
 Алексеев          Петров            Строка 1 меньше строки 2

     Кроме операции сравнения, к строковым переменным и константам можно применить операцию
сложения, в результате выполнения которой получается новая строка. Например, в результате выполнения
инструкций
     first_name: ='Иван';
     last_name:= 'Иванов';
     ful_name:= first_name+last_name;
переменная ful_name получит значение 'Иван Иванов'.

     7.3 Операции со строками

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

     7.3.1 Функция length

     Функция length возвращает длину строки. У этой функции один параметр  выражение строкового
типа. Значением функции length (целое число) является количество символов, из которых состоит строка.
     Например, в результате выполнения инструкций
     n:= length('Иванов');
     m:= length('Москва');
значение переменных n и m будет равно 6 и 8.




68
     7.3.2 Процедура delete

     Процедура delete позволяет удалить часть строки. В общем виде обращение к этой процедуре
выглядит так:
     delete(cтрока, р, n);
     где:
      строка  переменная или константа строкового типа;
      р  номер символа, с которого начинается удаляемая подстрока;
      n  длина удаляемой подстроки.
     Например, в результате выполнения инструкций
     p:='Язык программирования';
     delete(s,1,5);
значением переменной s будет строка 'программирования'.

     7.3.3 Функция роs

     Функция роs позволяет определить положение подстроки в строке. В общем виде обращение к
функции выглядит так:
     pos (подстрока, строка);
     где подстрока – строковая константа или переменная, которую надо найти в строковой константе или
переменной строка.
     Например, в результате выполнения инструкции р:= pos('ри','алгоритм') значение
переменной р будет равно 5. Если в строке нет искомой подстроки, то значение функции роs будет равно
нулю.
     Ниже приведена инструкция while, в результате выполнения которой удаляются начальные пробелы
из строки st.
     while(pos(’ ’,st) = 1) and(length(st) > 0) do delete (st,1,1);
     Пробелы удаляет инструкция delete (st, i, i), которая выполняется в цикле до тех пор, пока первым
символом строки является пробел (в этом случае значение роs (' ',st) равно единице). Необходимость
проверки условия length (st) > 0 объясняется возможностью того, что введенная строка состоит только из
пробелов.

     7.3.4 Функция сору

     Функция сору позволяет выделить фрагмент строки. В общем виде обращение к функции сору
выглядит так:
     сору( строка, р, n );
     где:
      строка  выражение строкового типа, содержащее строку, фрагмент которой надо получить;
      р  номер первого символа, с которого начинается выделяемая подстрока;
      n  длина выделяемой подстроки.
     Например, в результате выполнения инструкций
     st:= 'Инженер Иванов'; fam:=copy(st, 9, 6)
значением переменной fam будет строка «Иванов».

     7.3.5 Функция concat

     Возвращает строку, представляющую собой сцепление строк-параметров S1, S2, ... , SN. Обращение
к функции выглядит таким образом:
     concat (S1 , S2, ..., SN);
     Например, в результате выполнения инструкций
     S1:=’Студенты ’;
     S2:=’ 1 курса’;
     S:= concat(S1,S2);
значением переменной S будет строка 'Студенты 1 курса'.
     P:='Object'+' Pascal';// P содержит 'Object Pascal'
     В таблице 7.2 приводятся некоторые функции преобразования строк в другие типы.




                                                                                                   69
Таблица 7.2 – Подпрограммы преобразования строк в другие типы и обратного преобразования

 Function StrToDateTime(St: String): TDateTime;       Преобразует символы строки St в дату и время.
                                                      Строка должна содержать правильную дату и
                                                      правильное время, разделенные пробелом, например:
                                                      StrToDateTime('28.06 18:23')

 Function StrToFloat(St:String): Extended;            Преобразует символы строки St в вещественное
                                                      число. Строка не должна содержать ведущих или
                                                      ведомых пробелов

 Function StrToInt(St:String): Integer;               Преобразует символы строки St в целое число.
                                                      Строка не должна содержать ведущих или ведомых
                                                      пробелов

 Function FloatToStr(Value: Extended): String;        Преобразует вещественное значение Value в строку
                                                      символов

 Function FloatToStrF(Value: Extended; Format:        Преобразует вещественное значение Value в строку
 TFloatFormat; Precision, Digits: Integer): String;   символов с учетом формата Format и параметров
                                                      Precision и Digits (см. пояснения ниже)

 Function IntToStr(Value: Integer): String;           Преобразует целое значение Value в строку символов

Таблица 7.3 – Правила использования параметров функции FloatToStrF

     Значение Format                                           Описание

 ffExponent                   Научная форма представления с множителем ехх («умножить на 10 в
                              степени XX»). Precision задает общее количество десятичных цифр
                              мантиссы, Digits – количество цифр в десятичном порядке хх. Число
                              округляется с учетом первой отбрасываемой цифры: 3,1416Е+00

 ff Fixed                     Формат с фиксированным положением разделителя целой и дробной частей,
                              Precision задает общее количество десятичных цифр в представлении числа.
                              Digits – количество цифр в дробной части. Число округляется с учетом
                              первой отбрасываемой цифры. Например, ffFixed(Pi,6,2)= 3,14

 ff General                   Универсальный формат, использующий наиболее удобную для чтения
                              форму представления вещественного числа. Соответствует формату ffFixed,
                              если количество цифр в целой части меньше или равно Precision, а само
                              число – больше или равно 0,00001, в противном случае соответствует
                              формату ffExponent: 3,1416

     Для форматного преобразования вещественных чисел предназначены функции FloatToStrF и
FormatFloat. Первая использует значение Format перечисляемого типа TFloatFormat и два дополнительных
параметра  Precision и Digits. Правила использования параметров функции FloatToStrF показаны в
таблице 7.3 (примеры преобразования даются для Value =  = 3,141593654, Precision = 5 и Digits = 2).

     7.4 Лабораторная работа №7. Работа с символьными и строковыми данными

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

     Пример 1. Программа, текст которой приведен в листинге 7.1, выводит таблицу кодировки букв
русского алфавита. Вид окна программы представлен на рисунке 7.1.
     Основную работу выполняет процедура обработки события OnActivate, которая формирует и
выводит в поле метки (Label1) таблицу. Событие OnActivate происходит при активизации формы
приложения, и поэтому процедура TForm1.FormActivate выполняется автоматически, сразу после
появления формы на экране.


70
                   Рисунок 7.1 – Вид окна программы вывода таблицы символов

    Листинг 7.1 Процедура обработки события OnActivate

    procedure TForm1.FormActivate(Sender: TObject);
       var
       st:string; // таблица формируется как строка символов
       kod: byte; // код символа
       i,j:integer; // номер строки и колонки символов
           begin
             st:='';
             kod:=192;
             for i:=0 to 15 do // шестнадцать строк
             begin
             kod:=i + 192;
             for j:=1 to 4 do // четыре колонки
              begin
             st:=st+chr(kod)+'-'+IntToStr(kod)+'    ';
             kod:=kod + 16;
              end;
             st:=st + #13; // переход к новой строке экрана
             end;
             label1.caption:=st;
           end;

     Форма приложения Таблица символов содержит только один компонент  поле метки (Label1). Для
того чтобы колонки таблицы имели одинаковую ширину, свойству Label1.Font.Name следует присвоить
имя шрифта, у которого все символы имеют одинаковую ширину, например, Courier New.




                Рисунок 7.2 – Результат работы программы вывода таблицы символов

                                                                                             71
      Пример 2. Создать программу, в которой текст из строки ввода Edit1 будет копироваться без
изменений в метку Label2 и многострочный редактор Memo1.
      Вид формы показан на рисунке 7.2. На форме размещена панель (TPаnеl), две кнопки (TBitBtn),
строка ввода (TEdit), 2 метки (TLabel) и многострочный редактор (ТMеmо). Панель понадобилась для
того, чтобы размещенные на ней кнопки, строка ввода и метка всегда располагались в нижней части окна,
даже если окно распахнуто на весь экран. Левая кнопка ОК служит для сообщения программе о том, что в
строке ввода подготовлен текст. Обработчик события OnClick этой кнопки будет тем самым местом, куда
будет размещаться программа. Правая кнопка close служит для завершения работы программы. Ее
функции аналогичны функциям системной кнопки закрытия окна, и поэтому ее можно было бы и не
размещать на форме. Однако предпочтительно использовать крупную, бросающуюся в глаза кнопку,
чтобы даже неопытный пользователь сразу увидел интерфейсный элемент, с помощью которого он
сможет прекратить работу с программой. Метка располагается над строкой ввода и пока не видна на
экране. Она предназначена для размещения коротких сообщений, которые будет формировать программа.
Для вывода многострочных сообщений служит редактор TMеmо, занимающий все остальное место окна.

     Конструирование формы

     В соответствии с рисунком 7.2 сконструйте форму. В таблицах 7.4-7.9 для каждого компонента
указаны свойства, значения которых отличаются от умалчиваемых. Компоненты перечислены в порядке
их размещения, т. е. вначале подготавливаются свойства формы, потом на форму помещается панель, на
нее помещаются кнопки и строка ввода, а метка и многострочный редактор - на свободное место формы
над панелью.
     Размеры компонентов установлены с учетом разрешения экрана 800600. Для другого разрешения
эти размеры, возможно, потребуется скорректировать.




                                   Рисунок 7.3 – Окно формы примера 2

Таблица 7.4 – Свойства формы
    Свойство              Значение
 Caption           Копирование текста
 Height            375
 Name              Memo1
 Position          poScreenCenter
 Width             544

Таблица 7.5 – Свойства компонента panel (вкладка Standart)
    Свойство          Значение
 Align             AlBottom
 BevelOuter        BvNone
 Caption           Удалить
 Height            84


72
Таблица 7.6 – Свойства компонента BitBtn (кнопка OK на вкладке Additional)
    Свойство            Значение
 Kind               bkOk
 Left               32
 Name               bitBtn1
 Тор                48

Таблица 7.7 – Свойства компонента Edit1 (вкладка Standart)
 Свойство         Значение
 Name             Edit1
 Left             128
 Text             Удалить
 Top              16
 Width            289

    Для метки Label1 измените свойство Caption – дайте поясняющую надпись «Ввод исходных
данных».

Таблица 7.8 – Свойства метки Label2 (вкладка Standart)
 Свойство         Значение
 Align            alBottom
 Caption          Удалить
 Name             Label2

Таблица 7.9 – Свойства компонента Memo (Многострочный редактор)
 Свойство         Значение
 Align            alClient
 Lines            Удалить
 Name             Memo1
 ScrollBars       ssBoth
 Wordwrap         False

     Прокомментируем сделанные изменения умалчиваемых значений свойств.
     Размеры формы Height (Высота) и Width (Ширина) совпадают с умалчиваемыми. Они выбраны так,
чтобы форма не казалась слишком маленькой или слишком большой на экранах с разным разрешением 
они оптимальны для разрешения 800600. Свойство Position управляет размещением формы
относительно границ экрана. Умалчиваемое значение poDesigned потребует разместить форму так, как
она была размещена на этапе конструирования, рекомендуемое значение poScreencenter  симметрично
по центру экрана.
     Свойство Align указывает способ выравнивания размещаемого компонента относительно того
контейнера, в котором он размещается. Контейнером называется компонент, предназначенный для
размещения в нем других компонентов. Пустая форма представляет собой контейнер, в который
помещаются другие компоненты. Таким же контейнером является компонент panel. Мы разместили на
форме панель и в ее свойство Align установили значение alBottom (внизу). После установки этого
значения компонент (в данном случае  панель) прижимается к нижней границе формы и растягивается по
всей ее длине. Теперь панель и все размещенные на ней компоненты будут примыкать к нижнему краю
окна, даже если окно распахивается на весь экран. Если бы мы разместили строку ввода и кнопки не на
панели, а непосредственно на форме, они не имели бы свойства перемещения и оставались бы на своих
местах при изменении размеров окна.
     Свойство Caption (заголовок) присуще всем видимым элементам. Для панели оно определяет текст,
который размещается в ее центре. Поскольку мы не намерены размещать на панели никаких текстовых
сообщений, это свойство у нее следует очистить.
     Чтобы панель и расположенная над ней метка воспринимались как единое целое, в свойстве
BevelOuter (внешняя кромка) панели установлено значение bvNone.
     Свойство Text (текст) у компонента Edit1 определяет текст, который будет содержать строка ввода в
момент появления на экране. Следует очистить это свойство, чтобы начальный текст не мешал вводу
данных для программы. Точно так же следует очистить свойство Caption у метки 2 и Lines у
многострочного редактора. Чтобы очистить свойство Memo1. Lines, щелкните по этому свойству в окне



                                                                                                   73
Инспектора объектов и вызовите диалоговое окно изменения свойства. Затем удалите умалчиваемый текст
Memo1 и закройте окно кнопкой OK.
     Свойство ScrollBars у компонента Memo1 имеет значение ssBoth (оба). Такое значение позволяет
поместить в редактор обе полосы прокрутки  вертикальную и горизонтальную. Наличие полос поможет
увидеть текст, отсекаемый границами компонента. В то же время для свойства Wordwrap (перенос слов)
установим значение False, чтобы отказаться от переноса слов на другую строку редактора в длинных
текстовых сообщениях. Для этого компонента свойство Align имеет значение alclient, что потребует от
компонента занять всю оставшуюся незаполненной часть формы независимо от размеров окна.
     Для компонентов BitBtn свойство Kind (сорт) определяет типовые функции, которые реализует
кнопка в диалоговых окнах. Значение bkClose определит типовую пиктограмму и надпись close, которые
Delphi разместит на кнопке, а также типовую функцию закрытия окна, которая будет связана с этой
кнопкой. В результате без малейших усилий с нашей стороны мы получили кнопку, которая завершает
работу программы. Значение bkOK заставит кнопку BitBtn закрывать диалоговое окно. Поскольку наша
форма не является диалоговым окном, кнопка ОК не будет выполнять эту свою функцию: мы
использовали значение bkOK только для того, чтобы кнопка получила нужную пиктограмму и надпись.

     Написание программы

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

     procedure TForm1.BitBtn1Click(Sender: TObject);
        begin
             label2.Caption:= edit1.Text;// повторяем текст в метке 2
             Memo1.Lines.Add(edit1.Text); // и в многострочном редакторе
             edit1.Text:='';// очищаем строку ввода
             edit1.SetFocus;// // передаем ей фокус ввода
        end;

     Термином «фокус ввода» в Delphi фактически обозначается клавиатура. «Получить фокус ввода»
означает связать указанный компонент с клавиатурой.

     7.5 Индивидуальные задания

     Создайте приложение с использованием компонента TPanel, как показано в примере 2, для решения
одной из следующих задач. Ввод строки сделайте из поля редактирования. Вывод результата – в поле
Memo или окно редактирования.
     1. Дана строка символов. Преобразовать данную строку, удалив из нее каждую пару символов « « и
повторив (вставив еще раз) каждую пару символов » ». После преобразования полученную строку вывести
на печать.
     2. Дана строка символов. Исключить из этой строки группы символов, расположенные между
скобками [, ]. Сами скобки тоже дожны быть исключены. Предполагается, что внутри каждой пары скобок
нет других скобок.
     3. Дана строка символов, состоящая из нулей, единиц и пробелов. Группы нулей и единиц,
разделенные пробелами (одним или несколькими) и не содержащие пробелов внутри себя, будем называть
словами. Требуется подсчитать количество слов в данной строке.
     4. Дана строка, состоящая из n символов. Определить, имеется ли в последовательности пара
соседствующих букв ON или NO.
     5. Дана строка, состоящая из n символов. Определить, имеется ли в последовательности пара
соседствующих одинаковых символов.
     6. Дана строка, состоящая из n символов. Определить, имеется ли в последовательности пара
соседствующих символов, первый из которых – запятая, а второй – тире.
     7. Дана строка, состоящая из n символов. Заменить все восклицательные знаки точками.
     8. Дана строка, состоящая из n символов. Найти номер первой по порядку запятой, если их нет,
выдать соответствующее сообщение.
     9. Дана строка, состоящая из n символов. Удалить из данной последовательности сочетание
символов «ABCD».
    10. Дана строка, состоящая из n символов. Подсчитать наибольшее количество идущих подряд
пробелов.
    11. Дана строка, состоящая из n символов. Определить число вхождений в последовательность
группы символов «abc».

74
    12. Дана строка, состоящая из n символов. Подсчитать общее число вхождений символов «+», «-»,
«*».
    13. Дана строка, состоящая из n символов. Оставить в последовательности только строчные буквы,
прописные – удалить.
    14. Задана последовательность, содержащая от одного до тридцати слов, в каждом из которых от
одного до пяти букв, между соседними словами стоит запятая, в конце – точка. Вывести все слова,
которые встречаются в последовательности только по одному разу.
    15. Задана последовательность, содержащая от одного до тридцати слов, в каждом из которых от
одного до пяти букв, между соседними словами стоит запятая, в конце – точка. Вывести все слова в
алфавитном порядке.




                                                                                               75
                                            ЛИТЕРАТУРА

      1. Фаронов, В. В. Система программирования Delphi / В.В. Фаронов.  СПб.: БХВ-Петербург, 2005.
 912 с.
      2. Сухарев, М.В. Основы Delphi. Профессиональный подход / М.В. Сухарев.  СПб.: Наука и
техника, 2004.  600 с.
      3. Климова, Л.М. Delphi 7. Основы программирования. Решение типовых задач. Самоучитель / Л.М.
Климова. – М.: КУДИЦ-ОБРАЗ, 2004. – 480 с.
      4. Культин, Н.Б. Delphi в задачах и примерах / Н.Б. Культин. – СПб.: БХВ-Петербург, 2005. – 288 с.
      5. Культин, Н.Б.   Основы программирования в Delphi 7 / Н.Б. Культин. – СПб.: БХВ-Петербург
2003.
      6. Архангельский, А.Я. Язык Pascal и основы программирования в Delphi: учебное пособие / А.Я.
Архангельский. – М.: ООО «Бином-Пресс», 2004.  496 с.
      7. Сван, Т. Основы программирования в Delphi для Windows 95 / Т. Сван.  Киев: Диалектика.
1996.  480 с.
      8. Тейксейра, С. Delphi 5: Руководство разработчика.  Т.1: Основные методы и технологии
программирования: учебное пособие: пер. с англ. / С. Тейксейра, К. Пачеко.  М.: Изд. Дом «Вильямс»,
2000.  832 с.
      9. Бобровский, С.И. Delphi 5: Начальный курс / С.И. Бобровский.  М.: ДЕСС, Информком-Пресс,
1999.  271 с.




76
Севодина Галина Ивановна
Лисица Владимир Дмитриевич
Царегородцева Валентина Всеволодовна




ПРОГРАММИРОВАНИЕ В СРЕДЕ DELPHI


Лабораторный практикум по информатике для студентов инженерных и экономических
специальностей дневной формы обучения




                                  Редактор Идт Л.И.

                                  Подписано в печать 18.08.2006. Формат 6084 1/8
                                  Усл. п. л.  8,95. Уч.-изд. л.  9,6
                                  Печать  ризография, множительно-копировальный
                                  аппарат «RISO TR-1510»

                                  Тираж 50 экз. Заказ 2006-49
                                  Издательство Алтайского государственного
                                  технического университета
                                  656038, г. Барнаул, пр. Ленина, 46

                                  Оригинал-макет подготовлен ИИО БТИ АлтГТУ

                                  Отпечатано в ИИО БТИ АлтГТУ
                                  659305, г. Бийск, ул. Трофимова, 29




                                                                                    77

								
To top