ALTLinuxEdu
   1  
   2  IV. Программное обеспечение для объектно-ориентированного программирования и
   3  разработки приложений (Kdevelop, Lazarus, Gambas) ........................................................... 2
   4    1. Введение в ООП.................................................................................................................... 2
   5    2. Разработка ПО с использованием Kdevelop....................................................................... 16
   6       2.1. Основы языка программирования C++....................................................................... 17
   7       2.2. Работа со средой разработки ПО KDevelop................................................................ 30
   8    3. Разработка ПО с использованием Lazarus ......................................................................... 37
   9       3.1. Основы языка программирования Pascal.................................................................... 38
  10       3.2. Работа со средой разработки ПО Lazarus ................................................................... 48
  11    4. Разработка ПО с использованием Gambas ......................................................................... 54
  12       4.1. Основы языка программирования BASIC (ОО диалект) ........................................... 55
  13       4.2. Работа со средой разработки ПО Gambas................................................................... 61
  14  
  15  
  16  
  17  
  18  Академия АйТи                     Установка и администрирование ПСПО. Лекции. Часть 4                             Страница 1 из 67
  19         IV.          Программное                  обеспечение                    для        объектно-
  20  ориентированного программирования и разработки приложений
  21  (Kdevelop, Lazarus, Gambas)
  22         1. Введение в ООП
  23         Объектно-ориентированное               программирование              (ООП)      —       парадигма
  24  программирования (иными словами совокупность идей и понятий, определяющая стиль
  25  написания программ), в которой основными концепциями являются понятия объектов и
  26  классов.  Парадигма программирования определяет то, в каких терминах программист
  27  описывает логику программы. Например, в императивном программировании (самом
  28  прямолинейном подходе, где программа эквивалентна набору инструкций, т.е. это
  29  последовательность команд, которые должен выполнить компьютер) программа описывается
  30  как последовательность действий, а в функциональном программировании представляется в
  31  виде выражения и множества определений функций. В самом же популярном и
  32  рассматриваемом в данном курсе объектно-ориентированном программировании программу
  33  принято рассматривать как набор взаимодействующих объектов. ООП есть, по сути,
  34  императивное программирование, дополненное принципом инкапсуляции данных и методов
  35  в объект и          наследованием     (принципом повторного использования разработанного
  36  функционала). http://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%80%D0%B0%D0%B4%D0%B8%D0%B3%D0%BC%D0%B0_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F 
  37          Многие современные языки специально созданы для облегчения объектно-
  38  ориентированного программирования. Однако следует отметить, что можно применять
  39  техники ООП и для не объектно-ориентированного языка и наоборот, применение объектно-
  40  ориентированного языка вовсе не означает, что код автоматически становится объектно-
  41  ориентированным.
  42         Современный объектно-ориентированный язык предлагает, как правило, следующий
  43  обязательный набор синтаксических средств:
  44                  ·      Объявление классов с полями (данными) и методами (функциями).
  45                  ·      Механизм расширения класса (наследования) — порождение нового
  46          класса от существующего с автоматическим включением всех особенностей
  47          реализации класса-предка в состав класса-потомка.
  48                  ·      Средства        защиты          внутренней          структуры       классов        от
  49          несанкционированного использования извне. Обычно это модификаторы доступа к
  50  
  51  Академия АйТи             Установка и администрирование ПСПО. Лекции. Часть 4          Страница 2 из 67
  52          полям и методам, типа public, private, обычно также protected, иногда некоторые
  53          другие.
  54                  ·    Полиморфные         переменные         и     параметры   функций    (методов),
  55          позволяющие присваивать одной и той же переменной экземпляры различных
  56          классов.
  57                  ·    Полиморфное поведение экземпляров классов за счёт использования
  58          виртуальных методов. В некоторых ООП-языках все методы классов являются
  59          виртуальными.
  60         Видимо, минимальным традиционным объектно-ориентированным языком можно
  61  считать язык Оберон, который не содержит никаких других объектных средств, кроме
  62  вышеперечисленных. Но большинство языков добавляют к указанному минимальному
  63  набору те или иные дополнительные средства синтаксиса. В их числе:
  64                  ·    конструкторы, деструкторы, финализаторы;
  65                  ·    свойства (аксессоры);
  66                  ·    индексаторы;
  67                  ·    интерфейсы — как альтернатива множественному наследованию;
  68                  ·    переопределение операторов для классов;
  69                  ·    множество других усовершенствований базовых конструкций ООП
  70          парадигмы.
  71         Часть языков (иногда называемых "чисто объектными") целиком построена вокруг
  72  объектных средств — в них любые данные (возможно, за небольшим числом исключений в
  73  виде встроенных скалярных типов данных) являются объектами, любой код — методом
  74  какого-либо класса и невозможно написать программу, в которой не использовались бы
  75  объекты. Примеры подобных языков — Java, C# или Ruby. Программа, на этих языках
  76  состоящая из хотя бы одной строки кода, гарантировано будет содержать хотя бы один класс
  77  и/или объект. Другие языки (иногда используется термин "гибридные") включают ООП-
  78  подсистему в исходно процедурный язык. В них существует возможность программировать
  79  как с привлечением ООП парадигмы, так и не обращаясь к объектным средствам.
  80  Классические примеры таких языков — C++ и Delphi (Object Pascal). http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5
  81         Еще раз выделим разницу между объектно-ориентированным программированием
  82  (ООП) и объектно-ориентированным языком программирования (ОО-язык). ООП - это набор
  83  идей, концепций и методик облегчающий (как принято считать, хотя ООП постоянно
  84  
  85  Академия АйТи           Установка и администрирование ПСПО. Лекции. Часть 4        Страница 3 из 67
  86  подвергается довольно аргументированной критике) разработку сложных вычислительных
  87  систем. А ОО-язык берет на вооружение эти идеи и методики и средствами присущего
  88  только ему синтаксиса позволяет разработчику воспользоваться ими. В целом, берясь за
  89  любой новый ОО-язык, программист может быть практически уверен, что он сможет описать
  90  класс (или его аналог в данном языке), создать экземпляр класса, вызвать методы этого
  91  класса и т.д. Единственно существенный вопрос, который может (и должен) его волновать -
  92  КАК? Как все это реализуется, т.е. буквально - с чего начать описание класса, или какой
  93  конструкцией можно вызвать его метод (функцию). Для ответов на эти вопросы и изучают
  94  справочники и спецификации по синтаксису того или иного ОО-языка.
  95         Разумеется, каждый конкретный ОО-язык может реализовывать ОО-идеи несколько
  96  специфичным способом. Более того он может (и чаще всего так и происходит) расширять эти
  97  идеи какими-то собственными, присущими только ему или значительно более узкому кругу
  98  ОО-языков. Тем не менее, есть минимально допустимый набор концепций, который тем или
  99  иным способом реализован в абсолютном большинстве современных ОО-языков. Можно
 100  условно назвать этот набор термином «наименьший ОО-знаменатель». Язык, его не
 101  реализующий, вряд ли может быть помещен в таблицу «Современные ОО-языки».
 102         Итак - что же это за минимальный набор или "наименьший ОО-знаменатель"? Без чего
 103  решительно невозможно представить ОО-язык? Какие концепции являются буквально
 104  несущей конструкцией ООП? Их четыре:
 105         Абстракция данных
 106                  Классы   представляют        собою      упрощенное,        идеализированное    описание
 107         реальных сущностей предметной области. Если соответствующие модели адекватны
 108         решаемой задаче, то работать с ними оказывается намного удобнее, чем с
 109         низкоуровневым описанием всех возможных свойств и реакций класса.http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5
 110                  Пример: машина (автомобиль) - реальная сущность реального мира, класс Car -
 111         ее модель в мире программном. Вообще любой автомобиль характеризуется просто
 112         огромной кучей параметров - цвет, марка, модель, габариты, вес, грузоподъемность,
 113         число и диаметр колес и т.д. Обязан ли программист в классе Car полностью
 114         смоделировать машину реальную и указать все ее характеристики? Нет, ему
 115         достаточно создать модель достаточную и адекватную решаемой задаче. Например,
 116         мы можем постановить, что для создаваемой нами программы необходимо и
 117         достаточно знать всего два параметра: дату изготовления автомобиля и тип его кузова.
 118  
 119  Академия АйТи            Установка и администрирование ПСПО. Лекции. Часть 4           Страница 4 из 67
 120         Тогда, очевидно, мы разместим в классе Car 2 поля (поскольку атрибуты объектов
 121         реальных отражаются как раз на поля классов) с условными именами ДатаВыпуска и
 122         КузовТип. Если мы не ошиблись в наших оценках и этих двух полей действительно
 123         достаточно - все отлично, мы можем абстрагироваться от наличия прочих
 124         характеристик автомобиля реального. Однако если выяснится что программе (в лице
 125         других классов-потребителей) требуются вовсе не ДатаВыпуска и КузовТип а как раз
 126         ЦветКузова, МаксимальныйВес и Производитель нам придется имеющийся класс Car
 127         выкинуть и попросту начать с нуля. Дабы избежать подобных накладок и не тратить
 128         попусту труд и время разработчика ООП должно начинаться вовсе не с написания
 129         кода, а с вещи, возможно, даже более важной чем правильный и красивый код - с
 130         объектно-ориентированного проектирования будущей программы. Именно тут
 131         архитектор ПО должен принять стратегические решения - какие из характеристик
 132         объектов реальных необходимы и достаточны для их программного моделирования.
 133         Инкапсуляция
 134                  Это принцип, согласно которому любой класс должен рассматриваться как
 135         «чёрный ящик» — пользователь класса (а им, очевидно, будет какой-то второй класс,
 136         класс-потребитель) должен видеть и использовать только интерфейсную часть класса
 137         (т. е. список декларируемых свойств и методов класса) и не вникать в его внутреннюю
 138         реализацию. Поэтому данные принято инкапсулировать в классе таким образом, чтобы
 139         доступ к ним по чтению или записи осуществлялся не напрямую, а с помощью
 140         методов. Принцип инкапсуляции (теоретически) позволяет минимизировать число
 141         связей между классами и, соответственно, упростить независимую реализацию и
 142         модификацию классов.
 143                  Так же пример: телефон - реальная сущность реального мира, класс Phone - ее
 144         модель в мире программном. В телефоне реальном человек-пользователь (аналог
 145         класса-потребителя в мире программном) снимает трубку - набирает номер - кладет
 146         трубку. Все, это вся информация которую ему необходимо знать. Аналогично, класс
 147         Phone должен "выставлять наружу" примерно следующие 3 метода:
 148                        ·       ТрубкуПоднять()
 149                        ·       НажатьКлавишу(номер_клавиши)
 150                        ·       ТрубкуОпустить()
 151  
 152  
 153  
 154  Академия АйТи             Установка и администрирование ПСПО. Лекции. Часть 4   Страница 5 из 67
 155                  То, что при каждом нажатии клавиши телефона программного (как и реального)
 156         «реле FR45 посылает пиловидный импульс в выходную телефонную линию» не
 157         является необходимым знанием для ежедневной эксплуатации телефона и этот
 158         функционал не должен быть доступен ни реальному человеку, ни классу-потребителю.
 159         Поэтому метод Импульс_В_Линию() был бы объявлен внутри класса Phone как
 160         приватный, т.к. очевидно сам телефон (внутри) должен уметь посылать сигналы в
 161         линию, но вот сделать этот метод доступным извне, прочим классам, было бы грубой
 162         ошибкой и нарушением обсуждаемого принципа «черного ящика». Вызов публичного
 163         метода НажатьКлавишу(номер_клавиши) приводил бы к вызову метода приватного
 164         Импульс_В_Линию() что прекрасно согласуется с моделируемым объектом: нажатие
 165         физической клавиши действительно приводит к активности физического реле. Однако
 166         ситуация, когда никакая клавиша не нажата, а импульс все же сгенерен смотрелась бы
 167         очень странно и никак не укладывается в привычные рамки реального мира. «Черный
 168         ящик» нас от таких ситуаций успешно охраняет.
 169                  Второй пример, освещающий иной аспект того же самого принципа - аспект
 170         контролируемого доступа к состоянию класса. Предположим                 существование
 171         реального объекта - музыкального mp3-плеера. Не программного, а именно в виде
 172         коробочки с наушниками. Так же предположим, что весь его "интерфейс" состоит из
 173         одной физической кнопки A. Короткое нажатие на кнопку A переключает плеер между
 174         состояниями проигрывание/пауза и больше никакого управления не предусмотрено.
 175         Очевидно, что при программном моделировании класса Player мы бы ввели в него
 176         поле ПоложениеКнопкиA, т.к. статус этой кнопки является одной из характеристик, а
 177         они, как уже известно, отражаются на поля. Сначала давайте рассмотрим вариант,
 178         когда мы даем классу-потребителю прямой доступ к этому полю. Какие значения этот
 179         класс-потребитель мог бы в это поле поместить? Очевидно, он мог бы указать
 180         значение НАЖАТО (условный цифровой код 1) и ОТПУЩЕНО (условный цифровой
 181         код 0). Если бы классу- потребитель гарантировано предавал только эти 2 значения, да
 182         еще гарнировано в правильном порядке (что бы за каждым НАЖАТО непременно
 183         следовало ОТПУЩЕНО) - проблем бы не было никаких. Плеер реальный, как и Player-
 184         класс прекрасно понимают что надо делать при переходе из одного состояния в
 185         другое. Однако - как эти плееры должны реагировать при смене состояния НАЖАТО
 186         (1) опять в НАЖАТО (1)? Или - что делать при помещении в поле ПоложениеКнопкиA
 187  
 188  Академия АйТи            Установка и администрирование ПСПО. Лекции. Часть 4   Страница 6 из 67
 189         значения СДВИГ_ВПРАВО (условный цифровой код 2)? Наша кнопка A не умеет
 190         быть нажатой дважды без отпускания и уж тем более не умеет сдвигаться ни вправо,
 191         ни влево! Вот потому-то принцип инкапсуляции и утверждает - никаких
 192         непосредственных изменений внутреннего состояния класса извне, а только через
 193         предусмотренный специально для этих целей интерфейс. В случае класса Player было
 194         бы грамотным шагом введение публичного (доступного любому заинтересованному
 195         классу) метода с именем вроде A_Нажать_И_Отпустить(). Тогда бы мы полностью
 196         и корректно смоделировали поведение нашего реального прототипа. Точно как и на
 197         "живом"      mp3-плеере      потребители         класса      Player    теперь    могут       лишь
 198         нажать_и_отпустить кнопку A. А вот уже внутри метода A_Нажать_И_Отпустить()
 199         автор этого класса сам может изменять значение поля ПоложениеКнопкиA. Но такое
 200         изменение статуса является куда как более контролируемым и подвержено
 201         значительно меньшей вероятности возникновения ошибок. Авторы классов прекрасно
 202         осведомлены о внутреннем состоянии своих "питомцев" и, почти наверняка, автору
 203         класса Player и в голову не придет попытаться двигать кнопку в стороны вместо того,
 204         что бы нажимать на нее. Проблема заключается в том, что бы помешать сделать это
 205         гораздо менее искушенным во внутреннем устройстве класса Player потребителям и
 206         принцип "черного ящика" дает ответ этой проблеме. Коротко этот принцип
 207         формулируется так: классы-потребители в принципе не имеют доступа к приватным
 208         членам потребляемого ими класса, а, следовательно, не могут произвольно менять его
 209         состояние на любое им понравившееся. Любое изменение в статусе производится
 210         только с одобрения самого этого класса.
 211         Наследование
 212                  Наследованием называется возможность порождать один класс от другого с
 213         сохранением всех свойств и методов класса-предка (прародителя, иногда его называют
 214         суперклассом) и добавляя, при необходимости, новые свойства и методы. Набор
 215         классов, связанных отношением наследования, называют иерархией. Наследование
 216         призвано отобразить такое свойство реального мира, как иерархичность.
 217                  Традиционный пример, снова обратимся к машинам (автомобилям). Допустим
 218         нам необходимо реализовать классы ЛегковойАвтомобиль и ГрузовойАвтомобиль.
 219         Очевидно, эти два класса имеют общую функциональность. Так, оба они имеют 4
 220         колеса (для упрощения сделаем в вид, что 6-ти и более колесного транспорта не
 221  
 222  Академия АйТи           Установка и администрирование ПСПО. Лекции. Часть 4            Страница 7 из 67
 223         существует), двигатель, могут перемещаться и т.д. Всеми этими свойствами обладает
 224         любой автомобиль, независимо от того, грузовой он или легковой, 5- или 12-местный.
 225         Разумно вынести эти общие свойства и функциональность в отдельный класс,
 226         например, Автомобиль и наследовать от него два класса - ЛегковойАвтомобиль и
 227         ГрузовойАвтомобиль. Тогда поле МестПосадочных достаточно ввести только в классе
 228         Автомобиль, а два унаследованных класса получат это поле буквально "по
 229         наследству". Останется лишь установить нужное значение этого поля через
 230         публичный интерфейс. Более точно, если мы хотим, что бы потребители наших
 231         классов ЛегковойАвтомобиль и ГрузовойАвтомобиль могли изменять значение этого
 232         поля мы должны предусмотреть для них публичный интерфейс. Почему именно
 233         интерфейс? Потому что так диктует принцип инкапсуляции, он же "черный ящик". А
 234         что если мы попробуем игнорировать этот принцип? В самом деле - ну зачем нам еще
 235         дополнительная прокладка в виде метода УстановитьЧислоМестПосадочных()?
 236         Почему бы не позволить             потребителям быстренько менять           значение поля
 237         МестПосадочных без всяких посредников? Ну то что "быстренько" это, конечно,
 238         хорошо, но вот что делать двум проектируемым классам когда они однажды вдруг
 239         выяснят что могут вместить 7500 человек? Или, что еще "лучше", -5 человек? Вот для
 240         отсечения таких ситуаций обсужденный ранее принцип инкапсуляции соблюдать не
 241         просто         "хорошо            бы",           а          категорически       необходимо.
 242         УстановитьЧислоМестПосадочных() встанет на стражу наших интересов и не
 243         позволит моделировать нам (а более точно - потребителям создаваемых нами классов)
 244         автомобили с пассажирской емкостью в 20 самолетов. Кстати, и сам этот метод можно
 245         объявить в базовом классе, Автомобиль, наряду с полем МестПосадочных. Это еще
 246         больше подчеркнет преимущества обсуждаемого принципа - создается метод лишь
 247         однажды, а доступен потребителям как базового класса (Автомобиль) так и
 248         потребителям любого унаследованного от него класса.
 249         Полиморфизм
 250                  Полиморфизмом называют явление, при котором функции (методу) с одним и
 251         тем же именем соответствует разный программный код (полиморфный код) в
 252         зависимости от того, объект какого класса используется при вызове данного метода.
 253         Полиморфизм обеспечивается тем, что в классе-потомке изменяют реализацию метода
 254         класса-предка с обязательным сохранением сигнатуры метода. Иными словами
 255  
 256  Академия АйТи           Установка и администрирование ПСПО. Лекции. Часть 4        Страница 8 из 67
 257         требуется сохранить имя метода, тип и число его параметров, но можно изменить его
 258         тело. Это обеспечивает сохранение неизменным интерфейса класса-предка и
 259         позволяет осуществить связывание имени метода в коде с разными классами — из
 260         объекта какого класса осуществляется вызов, из того класса и берётся метод с данным
 261         именем. Такой механизм называется динамическим (или поздним) связыванием — в
 262         отличие от статического (раннего) связывания, осуществляемого на этапе компиляции.
 263                  В качестве примера этой концепции продолжим работу с базовым классом
 264         Автомобиль и двумя его унаследованными классами из предыдущего раздела. Как вы
 265         помните,              мы         закончили             созданием             публичного         метода
 266         УстановитьЧислоМестПосадочных() причем объявили его именно в базовом классе.
 267         В настоящий момент метод работает совершенно идентично, вызовем ли мы его из
 268         класса Автомобиль, или из класса ЛегковойАвтомобиль, или ГрузовойАвтомобиль.
 269         Напомню, что два последних класса получили этот метод "по наследству" из базового.
 270         Т.к. у нас есть физически один метод не удивительно, что именно он и будет
 271         отрабатывать из какого бы класса мы его не вызывали. Усложним задачу. Введем
 272         новое приватное поля в класс Автомобиль - ЧислоОбращений. Изначально значением
 273         этого поля будет 0, и, точно как и поле МестПосадочных, оно будет унаследовано
 274         обоими производными (иное название класса, унаследованного от какого-то базового
 275         класса) классами. Теперь сформулируем новые требования:
 276                           ·        если метод УстановитьЧислоМестПосадочных() вызывается из
 277                  класса       Автомобиль        -    изменить       (после      проверки)   значение       поля
 278                  МестПосадочных на указанное значение и больше ничего не делать
 279                           ·        если метод УстановитьЧислоМестПосадочных() вызывается из
 280                  класса ЛегковойАвтомобиль - изменить (после проверки) значение поля
 281                  МестПосадочных на указанное значение, а поле ЧислоОбращений увеличить на
 282                  единицу
 283                           ·        если метод УстановитьЧислоМестПосадочных() вызывается из
 284                  класса ГрузовойАвтомобиль - изменить (после проверки) значение поля
 285                  МестПосадочных на указанное значение, а поле ЧислоОбращений уменьшить
 286                  на единицу
 287                  Итак,          теперь          единый           до          этого       момента         метод
 288         УстановитьЧислоМестПосадочных распадается на 3 части:
 289  
 290  Академия АйТи                Установка и администрирование ПСПО. Лекции. Часть 4            Страница 9 из 67
 291                        ·        часть общая для всех классов - проверка переданного ему
 292                  значения и если все хорошо присвоение этого значения полю МестПосадочных
 293                        ·        часть характерная только для класса ЛегковойАвтомобиль, а
 294                  именно +1 к ЧислоОбращений
 295                        ·        часть характерная только для класса ГрузовойАвтомобиль, а
 296                  именно -1 к ЧислоОбращений
 297                  Разумеется практической смысловой нагрузки в таких требованиях не много, но
 298         как иллюстративный пример они подходят как нельзя лучше. Как же полиморфизм
 299         позволит нам изящно подстроиться под изменившиеся условия? А вот как:
 300                        ·        в       классе          Автомобиль               оставим      в        методе
 301                  УстановитьЧислоМестПосадочных() только общую часть и обозначим его как
 302                  "специальный" (с термином "специальный метод" мы разберемся чуть позже).
 303                  Что бы не привязываться к синтаксису конкретного ОО-языка запишем это на
 304                  псевдоязыке:
 305                        класс Автомобиль
 306                        {
 307                                 специальный
 308                  УстановитьЧислоМестПосадочных(места)
 309                                 {
 310                                         Проверить что число места разумно
 311                                         Если проверка прошла -
 312                                         поле МестПосадочных=места
 313                        }
 314                        }
 315                        ·        в унаследованных классах объявим тот же самый метод который
 316                  во-первых, вызовет свою реализацию из вышестоящего класса Автомобиль
 317                  (иногда ее называют базовой реализаций метода), а во-вторых предпримет
 318                  действия уникальные именно для этого класса. Снова псевдокод:
 319                        класс ЛегковойАвтомобиль унаследован_от Автомобиль
 320                        {
 321                                 специальный
 322                  УстановитьЧислоМестПосадочных(места)
 323  
 324  Академия АйТи             Установка и администрирование ПСПО. Лекции. Часть 4             Страница 10 из 67
 325                                {
 326  
 327  
 328                        Базовый.УстановитьЧислоМестПосадочных(места)
 329                                         ЧислоОбращений=ЧислоОбращений+1
 330                        }
 331                        }
 332  
 333  
 334                        класс ГрузовойАвтомобиль унаследован_от Автомобиль
 335                        {
 336                                специальный
 337                  УстановитьЧислоМестПосадочных(места)
 338                                {
 339  
 340  
 341                        Базовый.УстановитьЧислоМестПосадочных(места)
 342                                         ЧислоОбращений=ЧислоОбращений-1
 343                        }
 344                        }
 345                  Что получилось в результате? В результате у нас не 1, а 3 варианта одного и
 346         того же метода. Какой из них будет вызван зависит от того на каком классе будет
 347         вызван                   этот                   метод.                   Т.е.                теперь
 348         ЛегковойАвтомобиль.УстановитьЧислоМестПосадочных(5) совсем не тоже самое,
 349         что Автомобиль.УстановитьЧислоМестПосадочных(5), хотя первый метод и вызовет
 350         второй. Это, кстати, вовсе не обязанность унаследованного метода. Т.е. метод в
 351         ЛегковойАвтомобиль совершенно законно мог бы игнорировать своего коллегу-
 352         предшественника из класса Автомобиль, просто в нашей конкретной задаче оказалось
 353         удобным все же к нему обратиться.
 354                  Почему       же        в       новой        реализации          потребовалось        метод
 355         УстановитьЧислоМестПосадочных() обозначать как специальный и что вообще
 356         означает термин "специальный метод"? Специальным он стал потому, что компилятор
 357         должен обработать его особым образом, а вот методика и синтаксис такого
 358         "специального" обозначения разнится от ОО-языка к ОО-языку.                              Однако в
 359         большинстве ОО-языков "специальные" (в смысле разбираемой темы) методы
 360         называются виртуальными, а их синтаксическое обозначение обыгрывает или
 361  Академия АйТи             Установка и администрирование ПСПО. Лекции. Часть 4           Страница 11 из 67
 362         крутится вокруг слова virtual. Как отмечалось во введении к этому уроку есть ОО-
 363         языки где все методы изначально являются virtual, в них никаких особых обозначений
 364         не требуется. Тем не менее характерный ОО-язык все же проводит явное
 365         синтаксическое        различие      между методами            обычными        (не   виртуальными)         и
 366         виртуальными.
 367                   Ну а в чем же выражается упомянутая "специальная обработка" виртуального
 368         метода компилятором? Выражается она в том, что связь между виртуальным методом
 369         и вызывающими его процедурами и функциями устанавливается не во время
 370         компиляции (это называется ранним связыванием), а во время выполнения программы
 371         (позднее         связывание).      Иными        словами,        в     то      время    когда       метод
 372         УстановитьЧислоМестПосадочных() еще не был переделан нами в виртуальный,
 373         запись       ЛегковойАвтомобиль.УстановитьЧислоМестПосадочных(5)                            однозначно
 374         транслировалась компилятором в Автомобиль.УстановитьЧислоМестПосадочных(5).
 375         Невиртуальный метод всегда однозначно вызывается из того класса, который его
 376         объявил. После переделки того же метода в виртуальный компилятор встретив ту же
 377         строчку кода уже подобной трансляции не производит, а оставляет вопрос "какой же
 378         на       самом    деле    метод     вызвать?"       до    момента          непосредственного      вызова
 379         УстановитьЧислоМестПосадочных() во время выполнения программы. Когда теперь
 380         во время выполнения класс-потребитель заявляет что ему требуется именно метод
 381         класса ЛегковойАвтомобиль - именно так и случается. А если другой потребитель
 382         затребует тот же метод из ГрузовойАвтомобиль - то получит ожидаемое. Отметим, что
 383         невиртуальный метод вызывается чуть-чуть быстрее, т.к. исполняющая программа
 384         изначально         (еще     до     запуска)       точно       знает        адрес    целевого      метода
 385         (УстановитьЧислоМестПосадочных, в нашем примере). Адрес же виртуального
 386         метода рассчитывается непосредственно перед его вызовом (в момент когда
 387         программа уже работает). Однако расчеты эти столь ничтожны, а мощности
 388         современных настольных (не говоря уже о серверных) компьютеров столь
 389         значительны, что указанные потери в производительности программы можно
 390         полностью игнорировать.
 391         Итак - резюмируем четыре постулата ООП:
 392         Абстракция данных - классы моделируют объекты реального мира, однако делают
 393  это лишь до известной степени, не пытаясь достичь соответствия "один-к-одному"
 394  
 395  Академия АйТи               Установка и администрирование ПСПО. Лекции. Часть 4              Страница 12 из 67
 396         Инкапсуляция - классы выставляют для потребителей абсолютно минимально
 397  необходимый публичный интерфейс, все остальное должно быть скрыто
 398         Наследование - взаимоотношения между классами напоминают взаимоотношения
 399  между объектами реального мира и их группами, где Кошка - специализированный вид
 400  (класс) Млекопитающего, а те, в свою очередь, специализированный вид (класс) Животного.
 401  Каждый унаследованный класс точно умеет делать все что делает класс базовый (Кошка
 402  умеет кормить потомство молоком, как все Млекопитающие), но может (хоть и не обязан)
 403  привносить свою собственную функциональность (только Кошка умеет мяукать, ловить
 404  мышей, и шипеть на собак)
 405         Полиморфизм - одни и те же функции (методы) в классе базовом и производном
 406  могут иметь функционал и полностью идентичный, и частично совпадающий (см. наш
 407  последний пример с УстановитьЧислоМестПосадочных), и абсолютно различный.
 408         А кто является главными "действующими лицами" в ООП-мире? С какими
 409  сущностями чаще всего доведется работать ООП-программисту? Их всего две - класс и
 410  объект. И о первом (особенно), и о втором мы уже упоминали неоднократно, однако надо
 411  дать формальное их определение и, что более важно, очертить их взаимосвязь и их отличие
 412  друг от друга.
 413         Итак, класс, как можно уже было предположить из предшествующего рассказа, это
 414  программная сущность - модель реального объекта реального мира (хотя, разумеется, никто
 415  не может помешать вам смоделировать выдуманный объект мира фэнтезийного). Обычно
 416  классы состоят из полей (там хранятся атрибуты объектов типа цвета кузова авто и их
 417  состояния, типа запущен ли двигатель, или остановлен) и функций/методов (действия,
 418  который         класс   "умеет"    выполнять        -   ДвигательСтарт(),        ДвигательЗаглушить(),
 419  ЛеваяПередняяДверьЗакрыть() и т.д.).
 420         Что же до объектов, то в большинстве объектно- ориентированных языков
 421  программирования (таких как Java, C++ или С#), объекты являются экземплярами некоторого
 422  заранее описанного класса. Объекты в таких языках создаются с помощью конструктора
 423  класса, и уничтожаются (когда они становятся ненужными) либо с помощью деструктора
 424  класса (например, в C++), либо автоматически с использованием сборщика мусора (в Java,
 425  C#). Иными словами, класс - это план, по которому будет создан объект. Рассмотрим пример
 426  на псевдокоде:
 427         класс Дом
 428  
 429  Академия АйТи              Установка и администрирование ПСПО. Лекции. Часть 4         Страница 13 из 67
 430         {
 431                  цветКрыши
 432                  количествоОкон
 433  
 434  
 435                  цветКрышиЗадать()
 436                  количествоОконЗадать()
 437                  всеОкнаОткрыть()
 438         }
 439         Примерно так мы бы могли смоделировать реальный дом программно. Из целой кучи
 440  характеристик дома реального мы могли бы остановиться всего на двух (цвете крыши и
 441  количестве окон) и ограничиться двумя методами вспомогательными, помогающими эти
 442  характеристики устанавливать классам потребителям("черный ящик" - помните?) и одним
 443  методом, утверждающим что наш класс будет уметь открывать окна. Самое интересно, что
 444  последняя фраза не совсем корректна. Класс - это проект, а не объект программного мира.
 445  Класс действительно мог бы открыть окна если бы они у него были. Но их нет! Они только
 446  будут у объекта созданного "по кальке" класса.
 447         Тут не совсем удачно пересекаются термины объект (реального мира; из него
 448  архитектор ПО придумывает класс) и одноименный ему объект (мира программного,
 449  получаемый из чертежа-класса). Для прояснения картины запомним схему - кто откуда
 450  "вытекает":
 451         ОБЪЕКТ реальный (автомобиль) à класс Car à ОБЪЕКТ программный (MyGreenCar)
 452         Так же отметим, что ОБЪЕКТ программный иногда называют экземпляром, однако
 453  термин объект все же употребляется чаще даже невзирая на его неоднозначность.
 454         Имея "чертеж" дома (класс Дом) мы можем наштамповать сколько угодно домов-
 455  объектов, например:
 456         МойДом=новый Дом()
 457         МойДом.цветКрышиЗадать("зеленый")
 458         МойДом.количествоОконЗадать(3)
 459         ДомРодителей=новый Дом()
 460         ДомРодителей.цветКрышиЗадать("синий")
 461         ДомРодителей.количествоОконЗадать(4)
 462         ДомПриятеля=новый Дом()
 463  
 464  Академия АйТи           Установка и администрирование ПСПО. Лекции. Часть 4   Страница 14 из 67
 465         ДомПриятеля.цветКрышиЗадать("красный")
 466         ДомПриятеля.количествоОконЗадать(5)
 467 468         Элемент кода вида новый Дом()присутствует в том или ином синтаксисе в любом
 469  ОО-языке и называется конструктором объекта. Его назначение именно такое какое и
 470  вытекает из названия - сконструировать новый объект по классу-чертежу и позволить нам
 471  получить доступ к его функциям / методам.
 472         Как видите проблема только одна - придумать каждому объекту уникальное имя, и в
 473  общем случае совпадение с именем класса не допускается. И вот только теперь, когда у нас
 474  есть программный объект - копия (пусть и сильно усеченная) объекта реального мы можем
 475  начинать открывать окна:
 476         МойДом.всеОкнаОткрыть()
 477         ДомРодителей.всеОкнаОткрыть()
 478         ДомПриятеля.всеОкнаОткрыть()
 479  
 480  
 481         При этом в общем случае (однако - см. примечание в конце урока) строка
 482         Дом.всеОкнаОткрыть()
 483         вызовет ошибку компиляции. Класс определяет, что будут уметь делать полученные
 484  из него (или, если хотите, "от него") объекты, но не он сам.
 485         Итого, ответ на поставленный ранее вопрос: объект (программный) создается по
 486  "чертежу"-классу и в этом смысле является полностью от него зависящим. Не будет класса -
 487  определенно не будет объекта. В то же время, класс всего лишь планирует характеристики
 488  (атрибуты) и функционал будущих своих объектов, но сам ими не обладает и производить
 489  какую-либо      активность    не    может.      Иными        словами,         что   бы   воспользоваться
 490  функциональностью заложенной в классе (открыть окно в Доме) потребитель обязан создать
 491  его объект; иначе требуемая функциональность будет попросту недоступна.
 492  
 493  
 494  
 495  
 496  Академия АйТи           Установка и администрирование ПСПО. Лекции. Часть 4              Страница 15 из 67
 497         2. Разработка ПО с использованием Kdevelop
 498         KDevelop — свободная среда разработки программного обеспечения для UNIX-
 499  подобных операционных систем. KDevelop не включает в свой состав компилятор; иными
 500  словами сам по себе KDevelop не умеет переводить текст написанный программистом в код
 501  годный для выполнения на компьютере. KDevelop только предоставляет удобную среду для
 502  набора такого текста, его редактирования, отладки и прочих типичных задач разработчика.
 503  Однако для самого важного этапа в разработке ПО - перевод текста программы на языке
 504  высокого уровня (допустим Pascal), в эквивалентную программу на машинном языке (или,
 505  как еще говорят, перевод в двоичный код) - ему требуется помощь внешней программы-
 506  компилятора. Такие программы существуют сами по себе, независимо от KDevelop и в целом
 507  текст набранный в любом редакторе (в KDevelop в т.ч.) можно использовать как входной
 508  файл для компилятора вне зависимости от того установлена у нас среда разработки или ее
 509  нет вообще. Компилятор наличием/отсутствием KDevelop не интересуется; ему нужен
 510  синтаксически корректный файл на входе и более ничего, методика создания этого файла
 511  компилятору безразлична.
 512         Однако KDevelop умеет очень гладко осуществлять передачу набранного в нем текста
 513  разрабатываемой программы компилятору, прием сообщений от компилятора о ходе
 514  компиляции и, по окончании этого процесса, выдачу соответствующих сообщений
 515  программисту. Таким сообщением может быть известие о том, что ошибок компиляции не
 516  обнаружено, а поэтому исполнительный (двоичный) модуль успешно собран и готов к
 517  тестовому запуску. Или, напротив, сообщение о, например, 3-х ошибках компиляции с
 518  указанием строк исходной программы их вызвавших. Ясно, что такой подход сильно
 519  повышает эффективность работы разработчика по сравнению с "прямой" работой с
 520  компилятором и чтением выдаваемых им сообщений в консольном окне, да и редактор
 521  встроенный в эту среду значительно более удобен и продвинут по сравнению со
 522  стандартным.
 523         KDevelop умеет взаимодействовать описанным выше способом не с одним
 524  конкретным компилятором, а с их множеством. Т.е. используя эту среду можно создавать
 525  программы на многих языках программирования. Далеко не полный их перечень включает в
 526  себя такие языки как Ада, Bash, C, C++, Фортран, Java, Pascal, Perl, PHP, Python, Ruby и SQL.
 527  При этом и программист на Фортране и Паскаль-программист работают в одной и той же
 528  графической среде, с одним и тем же редактором и могут пользоваться всеми инструментами
 529  
 530  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4   Страница 16 из 67
 531  и вспомогательными окнами встроенными в KDevelop. Различие (да и то не столь явно
 532  выраженное визуально) проявится в момент когда каждый из них даст команду на
 533  компиляцию своей программы (или, как еще говорят, на сборку проекта): у первого
 534  отработает Фортран-компилятор, а у второго Паскаль- компилятор. Однако они оба получат
 535  соответствующие уведомления в конце этого процесса.
 536         Разумеется, в рамках нашего курса не возможно рассмотреть создание программ на
 537  всех и каждом языке из списка поддерживаемых KDevelop. Поэтому в качестве нашего
 538  рабочего инструмента выберем C++ как один из (если не самый) популярных ОО-языков. Т.е.
 539  мы готовы попробовать создавать несложные программы на языке C++ в среде KDevelop.
 540  Для этого, очевидно, мы должны быть компетентны в двух не связанных областях
 541  компьютерной науки:
 542                  ·     мы должны знать и уметь писать синтаксически корректные программы
 543          на C++ как таковом, вне зависимости от используемой среды разработки
 544                  ·     мы должны знать KDevelop именно как приложение и уметь
 545          пользоваться предлагаемым им функционалом опять же, вне зависимости от языка на
 546          котором мы будем работать
 547         Соединение этих двух компетенций приведет к созданию именно C++ - программ
 548  именно с помощью среды KDevelop.
 549         Рассмотрим эти вопросы последовательно в следующих двух подразделах.
 550  
 551  2.1. Основы языка программирования C++
 552         C++ —        компилируемый строго типизированный язык программирования общего
 553  назначения. Поддерживает разные парадигмы программирования, но наибольшее внимание
 554  уделено поддержке объектно-ориентированного подхода. C++ справедливо считают трудным
 555  для изучения языком в виду его сложности и избыточности.
 556         В виду ограниченного объема нашего курса и несколько иной его направленности мы
 557  ограничимся лишь самыми базовыми конструкциями языка, да и то не всеми. При желании
 558  обучение может быть продолжено самостоятельно по учебникам и статьям, опубликованным
 559  в печатной и электронной прессе (Интернет). Объем информации находящейся в сети даже в
 560  свободном доступе более чем достаточен для изучения C++ с любой степенью погружения в
 561  его нюансы. Отметим, что базовое знание английского языка (технического) хоть и не
 562  является обязательным условием для успешного освоения C++, способно сильно облегчить и
 563  ускорить учебный процесс.
 564  Академия АйТи            Установка и администрирование ПСПО. Лекции. Часть 4   Страница 17 из 67
 565         Итак, простейшая C++ программа производящая какую-то активность может иметь
 566  вид:
 567         #include <iostream>
 568         using namespace std;
 569         int main()
 570         {
 571             cout << "Учимся программировать на языке С++!";
 572             return 0;
 573         }
 574         Разберем ее строчка за строчкой:
 575         #include <iostream>
 576         При      компиляции    программы        директива      препроцессора   #include   заставляет
 577  компилятор включить содержимое заданного файла в начало вашей программы. В данном
 578  случае компилятор включит содержимое файла iostream. Файлы которые вы включаете в
 579  начало (или заголовок) вашей программы, называются заголовочными файлами. Обычно они
 580  имеют расширение .h, однако данный случай - особый, нам нужен именно файл iostream (без
 581  расширения), а не iostream.h. В данный момент не беспокойтесь о внутреннем содержимом
 582  заголовочных файлов. Просто поймите, что оператор #include позволяет вам использовать эти
 583  файлы. Каждая создаваемая вами программа на C++ начинается с одного или нескольких
 584  операторов #include. Эти операторы указывают компилятору включить содержимое
 585  заданного файла (заголовочного файла) в вашу программу, как если бы программа содержала
 586  операторы, которые находятся во включаемом файле. Замечание: никогда не изменяйте
 587  содержимое заголовочных файлов. Это может привести к ошибкам компиляции в каждой
 588  создаваемой вами программе. Однако просмотр (без редактирования) этих файлов является
 589  хорошей практикой для постижения внутренней структуры C++ - программ.
 590         using namespace std;
 591         Говорит о том, что в дальнейшем тексте программы необходимо использовать
 592  идентификаторы из указанного именного пространства (namespace - пространство имен).
 593  Пока можно просто принять как данность, что наша первая C++-программа "желает"
 594  работать в пространстве имен с именем std, и отложить рассмотрение самой концепции
 595  namespace до лучших времен.
 596  
 597  Академия АйТи           Установка и администрирование ПСПО. Лекции. Часть 4       Страница 18 из 67
 598         int main()
 599         В    каждой   С++   программе       должна      быть     ровно        одна   функция с     именем
 600  main().Исполнение программы начинается с выполнения первой инструкции функции main(),
 601  в нашем случае – cout. Затем одна за другой исполняются все дальнейшие инструкции
 602  (которых в нашем минимальном примере нет), и, выполнив последнюю инструкцию функции
 603  main(), программа заканчивает работу.
 604         Функция (не только main, а любая) состоит их четырех частей: типа возвращаемого
 605  значения, имени, списка параметров и тела функции. Первые три части составляют прототип
 606  функции.
 607         Список параметров заключается в круглые скобки и следует всегда за именем
 608  функции. В нашем случае пустые круглые скобки означают, что main не ждет никаких
 609  параметров. Слово int на месте типа возвращаемого значения говорит о том метод main
 610  собирается вернуть какое-то значение целого типа (int - целое число).                    Тело функции
 611  содержит последовательность исполняемых инструкций и ограничено фигурными скобками.
 612  Второе назначение таких скобок - группировка операторов. Это такой набор операторов,
 613  которые компьютер должен выполнить определенное число раз (цикл), или другой набор
 614  операторов, которые компьютер должен выполнить, если выполняется определенное условие.
 615  В обоих случаях мы увидим открывающую и закрывающую фигурную скобки внутри тела
 616  той или иной функции. Наш пример слишком прост для циклов и условий и никаких
 617  группировок не использует.
 618         cout << "Учимся программировать на языке С++!";
 619         Третья инструкция является инструкцией вывода. cout – это выходной поток,
 620  направленный на терминал, << – оператор вывода. Полностью эта инструкция выводит в cout
 621  – то есть на терминал – символьную константу, заключенную в двойные кавычки. В
 622  результате выполнения данной инструкции мы получим на терминале сообщение:
 623         Учимся программировать на языке С++
 624         return 0;
 625         Наш метод main обязался вернуть некоторое целое значение. Для этого следует
 626  воспользоваться оператором return после которого и указать это самое значение. Если
 627  оператор return опустить ошибки компиляции не произойдет, однако во время выполнения
 628  наш метод будет возвращать некоторое случайное значение ("мусор").
 629  
 630  
 631  
 632  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4             Страница 19 из 67
 633         Точка с запятой в конце инструкции собственно, обозначает именно этот факт - конец
 634  иструкции. Программист обязан ставить этот символ (;) в конце каждой инструкции.
 635         Типичная программа с функциональностью хотя бы чуть-чуть сложнее только что
 636  показанной определенно должна хранить какую-то информацию во время своего
 637  выполнения. Например, программе, печатающей файл, нужно знать имя файла и, возможно,
 638  число копий, которые вы хотите напечатать. В процессе выполнения программы хранят
 639  такую информацию в памяти компьютера. Чтобы использовать определенные ячейки памяти,
 640  программы применяют переменные. Проще говоря, переменная представляет собой имя
 641  ячейки памяти, которая может хранить конкретное значение. Когда вы присваиваете значение
 642  переменной, представьте себе переменную в виде ящика, в который можно поместить
 643  значение. Если вам позже потребуется использовать значение переменной, компьютер просто
 644  посмотрит значение, содержащееся в ящике.
 645          Ваши программы используют переменные для хранения информации. В зависимости
 646  от типа хранимого значения, например, целое число, буква алфавита или число с плавающей
 647  точкой, тип вашей переменной будет разным. Тип переменной указывает тип значения,
 648  хранимого в переменной, а также набор операций (таких как сложение, умножение и другие),
 649  которые программа может выполнять над значением переменной. Большинство программ на
 650  C+ + будут использовать типы переменных, перечисленные в табл. 3.1
 651  
 652         Тип              Диапазон хранимых значений
 653  
 654                          Значения в диапазоне от -128 до 127. Обычно используется для
 655         char
 656                    хранения букв алфавита
 657  
 658         int              Значения в диапазоне от -32768 до 32767
 659  
 660         unsigned         Значения в диапазоне от 0 до 65535
 661  
 662         long             Значения в диапазоне от -2147483648 до 2147483647
 663  
 664         float            Значения в диапазоне от -3.4 x 10-38 до 3.4 x 1038
 665  
 666         double           Значения в диапазоне от 1.7х 10-308 до 1.7х 10308
 667  
 668         Таблица .1. Наиболее востребованные типы переменных C++.
 669         Прежде чем вы сможете использовать переменную, ваша программа должна ее
 670  объявить. Другими словами, вам следует представить переменную компилятору C++. Чтобы
 671  объявить переменную в программе, вам следует указать тип переменной и ее имя, по
 672  
 673  
 674  Академия АйТи           Установка и администрирование ПСПО. Лекции. Часть 4   Страница 20 из 67
 675  которому программа будет обращаться к данной переменной. Указывайте тип и имя
 676  переменной после открывающей фигурной скобки главной программы, как показано ниже:
 677            тип_переменной имя_переменной;
 678            Как правило, тип переменной будет одним из типов, перечисленных в табл. 3.1.
 679  Выбираемое вами имя переменной должно нести смысловую нагрузку, которая описывает
 680  (для всех, кто читает вашу программу) использование переменной. Например, ваша
 681  программа могла бы использовать переменные, такие как employee_name, employee_age и т.
 682  д. Обратите внимание на точку с запятой, которая следует за именем переменной. В C++
 683  объявление переменной считается инструкцией. Поэтому вы должны поставить после
 684  объявления точку с запятой, точно так же как ставите ее в конце инструкции производящей
 685  какую-то активность типа печати строки.
 686            Фрагмент следующей программы объявляет три переменные, используя типы int, float
 687  и long:
 688            #include <iostream>
 689            int main()
 690            {
 691                int test_score;
 692                float salary;
 693                long distance_to_mars;
 694            }
 695            Важно обратить внимание, что данная программа ничего не выполняет, а только
 696  объявляет переменные (тем не менее, формально это полноценная C++ - программа). Как
 697  видите, объявление каждой переменной заканчивается точкой с запятой. Если вы объявляете
 698  несколько переменных одного и того же типа, можно разделять их имена запятой.
 699  Следующий оператор, например, объявляет три переменных с плавающей точкой:
 700            float salary, income_tax, retirement_fund;
 701            После объявления переменной вы используете оператор присваивания C++ (знак
 702  равно), чтобы присвоить значение переменной. Фрагмент следующей программы сначала
 703  объявляет переменные, а затем использует оператор присваивания, чтобы присвоить
 704  переменным значения:
 705            #include <iostream>
 706            int main()
 707  
 708  Академия АйТи                   Установка и администрирование ПСПО. Лекции. Часть 4   Страница 21 из 67
 709           {
 710               int age;
 711               float salary;
 712               long distance_to_the_moon;
 713  
 714  
 715               age = 32;
 716               salary = 25000.75;
 717               distance_to_the_moon = 238857;
 718           }
 719           При объявлении переменной часто удобно присваивать ей начальное значение. Чтобы
 720  упростить такую процедуру, C++ позволяет присваивать значение во время объявления
 721  переменной (т.е. свести объявление и присвоение в одну инструкцию), как показано ниже:
 722           int age = 32;
 723           float salary = 25000.75;
 724           long distance_to_the_moon = 238857;
 725           После присвоения значения переменной ваши программы могут использовать это
 726  значение, просто обращаясь к ее имени. Следующая программа присваивает значения трем
 727  переменным и затем выводит значение каждой переменной, используя cout:
 728           #include <iostream>
 729           using namespace std;
 730           int main()
 731           {
 732               int age = 32;
 733               float salary = 25000.7;
 734               long dis_to_moon = 238857;
 735               cout << "Служащему " << age << " года (лет)" << endl;
 736               cout << "Оклад служащего составляет $" << salary << endl;
 737               cout << "От земли до луны " << dis_to_moon << " миль" << endl;
 738           }
 739  
 740  
 741           Когда вы откомпилируете и запустите эту программу, на экране появится следующий
 742  вывод:
 743  
 744  Академия АйТи                Установка и администрирование ПСПО. Лекции. Часть 4   Страница 22 из 67
 745         Служащему 32 года (лет)
 746         Оклад служащего составляет $25000.7
 747         От земли до луны 238857 миль
 748  переделка под Линукс с http://programmersclub.ru/04/
 749  
 750         Независимо от целевого назначения большинство ваших программ на C++ будут
 751  складывать, вычитать, умножать или делить те или иные значения. Ваши программы могут
 752  выполнять арифметические операции с константами (например, 3*5) или с переменными
 753  (например, payment — total). Таблица 2 перечисляет основные математические операции
 754  C++:
 755         Операция                              Назначение                               Пример
 756         +                                     Сложение                                 total = cost + tax;
 757         -                                     Вычитание                                change = payment -
 758                                                                               total;
 759         *                                     Умножение                                tax = cost * tax_rate;
 760         /                                     Деление                                  average = total / count;
 761         Таблица2. Основные математические операции С++.
 762  
 763  
 764         Следующая программа использует cout для вывода результата нескольких простых
 765  арифметических операций:
 766         #include <iostream>
 767         using namespace std;
 768         int main()
 769         {
 770             cout << "5 + 7 = " << 5 + 7 << endl;
 771             cout << "12 - 7 = " << 12 - 7 << endl;
 772             cout << "1.2345 * 2 = " << 1.2345 * 2 << endl;
 773             cout << "15 / 3 = " << 15 / 3 << endl;
 774         }
 775  
 776  
 777         Посмотрите внимательно на операторы программы. Обратите внимание, что каждое
 778  выражение сначала появляется в кавычках, которые обеспечивают вывод символов
 779  (например, 5 + 7 =) на экран. Затем программа выводит результат операции и символ новой
 780  
 781  Академия АйТи              Установка и администрирование ПСПО. Лекции. Часть 4               Страница 23 из 67
 782  строки. Когда вы откомпилируете и запустите эту программу, на вашем экране появится
 783  следующий вывод:
 784         5 + 7 = 12
 785         12 - 7 = 5
 786         1.2345 * 2 = 2.469
 787         15 / 3 = 5
 788  
 789  
 790         В данном случае программа выполняла арифметические операции, используя только
 791  постоянные значения. Следующая программа выполняет арифметические операции,
 792  используя переменные:
 793         #include <iostream>
 794         using namespace std;
 795         int main()
 796         {
 797             float cost =15.50; // Стоимость покупки
 798             float sales_tax = 0.06; // Налог на продажу 6%
 799             float amount_paid = 20.00; // Деньги покупателя
 800             float tax, change, total; // Налог на продажу, сдача покупателю и общий счет
 801             tax = cost * sales_tax;
 802             total = cost + tax;
 803             change = amount_paid - total;
 804             cout << "Стоимость покупки: $" << cost << "\tHaлor: $" << tax << "\tОбщий счет: $"
 805  << total << endl;
 806             cout << "Сдача покупателю: $" << change << endl;
 807         }
 808  
 809  
 810         В данном случае программа использует только переменные с плавающей точкой. Как
 811  видите, программа присваивает значения переменным при объявлении и комментирует
 812  назначение каждой (о комментариях будет сказано в конце данного раздела). Далее
 813  программа выполняет арифметические операции над переменными для определения налога
 814  на продажу, общего счета и сдачи покупателю. Общая стоимость покупки, Налог и Общий
 815  счет выводятся в одну строку, но отделяются друг от друга знаками табуляции. Об этом
 816  
 817  Академия АйТи               Установка и администрирование ПСПО. Лекции. Часть 4   Страница 24 из 67
 818  говорят специальные символы, составленные из косой черты и буквы t. Сдача выводится
 819  отдельной строкой. Когда вы откомпилируете и запустите эту программу, на вашем экране
 820  появится следующий вывод:
 821         Стоимость покупки: $15.5                  Налог: $0.93 Общий счет: $16.43
 822         Сдача покупателю: $3.57
 823  практически полностью содрано с http://programmersclub.ru/05/ 
 824  
 825         Класс представляет собой главное инструментальное средство C++ для объектно-
 826  ориентированного программирования. Т.е. конструкция определяемая в С++ программе с
 827  привлечением ключевого слова class позволяет реализовывать те идеи и концепции ООП о
 828  которых шла речь в первой части курса. Как вы уже знаете класс группирует элементы,
 829  соответствующие данным о некотором объекте реального мира, и оперирующие этими
 830  данными функции (называемые методами). Группируя данные об объекте и кодируя их в
 831  одной переменной-классе, вы упрощаете процесс программирования и увеличиваете
 832  возможность повторного использования своего кода.
 833         Класс C++ должен иметь уникальное имя, за которым следует открывающая фигурная
 834  скобка, один или несколько элементов (а ими, традиционно, будут поля и методы) и
 835  закрывающая фигурная скобка. Т.е. схема объявления класса такая:
 836         class class_name
 837         {
 838              int data_member; // Элемент данных, поле
 839              void show_member(int); // Функция-элемент, метод
 840         };
 841         После определения класса вы можете объявлять переменные типа этого класса
 842  (называемые объектами, или, для избегания путаницы между объектами реальными и
 843  программными - экземплярами), как показано ниже:
 844         class_name object_one, object_two, object_three;
 845         Следующее определение создает класс employee, который содержит определения трех
 846  полей и одного метода:
 847         class employee
 848         {
 849              public:
 850             char name[64];
 851              long employee_id;
 852  
 853  Академия АйТи               Установка и администрирование ПСПО. Лекции. Часть 4    Страница 25 из 67
 854              float salary;
 855  
 856  
 857              void show_employee(void)
 858              {
 859                  cout << "Имя: " << name << endl;
 860                  cout << "Номер служащего: " << employee_id << endl;
 861                  cout << "Оклад: " << salary << endl;
 862              };
 863         };
 864  
 865  
 866         Обратите внимание на использование метки public внутри определения класса.
 867  Элементы класса могут быть частными (private) или общими (public), от чего зависит, как
 868  ваши программы обращаются к элементам класса. В данном случае все элементы являются
 869  общими (т.к. в теле нашего класса есть секция public и отсутствует секция private), это
 870  означает, что программа (т.е. другие классы отличные от employee, классы-потребители)
 871  может обращаться к любому элементу класса employee, используя оператор точку(.) и мы
 872  вскоре увидим как именно этот оператор применяется. Как мы знаем это прямое нарушение
 873  принципа инкапсуляции ("черный ящик") и не должно быть допустимо в проектах реальных.
 874  Здесь же такой подход применен единственно с целью не переусложнять пример новой
 875  конструкции языка - class.
 876         Так же следует обратить внимание на определение поля name, которое включает число
 877  64 в квадратных скобках. Если это число со скобками убрать name был бы объявлен как
 878  обычный char. Т.е. он мог бы содержать ровно один символ(цифру или букву или знак
 879  пунктуации). Привлечение квадратных скобок сообщает компилятору о том, что name будет
 880  представлен не как единичный символ, а как массив таких символов. Массив – это набор
 881  данных одного типа, например массив целых чисел или массив символов, как в данном
 882  случае. По итогу получается, что каждой переменной типа char[64] будет выделено
 883  достаточно памяти, что бы разместить 64 символа. В совокупности они как раз достаточны,
 884  что бы указать с их помощью имя сотрудника.
 885         Продолжим работу с классом employee. После определения класса внутри вашей
 886  программы (мы сделали это только что) вы можете объявить объекты (экземпляры) типа
 887  этого класса, как показано ниже:
 888  
 889  Академия АйТи                Установка и администрирование ПСПО. Лекции. Часть 4   Страница 26 из 67
 890         employee worker, boss, secretary;
 891  
 892  
 893         Т.е. совершенно аналогично элементарным типам из таблицы 3.1 - сначала идет тип
 894  экземпляра, затем - его уникальное имя или несколько имен через запятую как в данном
 895  случае.
 896         Следующая программа создает два объекта (экземпляр) типа employee. Используя
 897  оператор точку, программа затем присваивает значения полям этих объектов. Затем
 898  программа использует метод show_employee() для вывода информации о служащем:
 899         #include <iostream.h>
 900         #include <string.h>
 901         using namespace std;
 902  
 903  
 904         class employee
 905         {
 906         public:
 907              char name [64];
 908              long employee_id;
 909              float salary;
 910  
 911  
 912              void show_employee(void)
 913              {
 914                   cout << "Имя: " << name << endl;
 915                   cout << "Номер служащего: " << employee_id << endl;
 916                   cout << "Оклад: " << salary << endl;
 917              };
 918         };
 919  
 920  
 921         int main()
 922         {
 923              employee worker, boss;
 924              strcpy(worker.name, "John Doe");
 925              worker.employee_id = 12345;
 926              worker.salary = 25000;
 927  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4   Страница 27 из 67
 928              strcpy(boss.name, "Happy Jamsa");
 929              boss.employee_id = 101;
 930              boss.salary = 101101.00;
 931              worker.show_employee();
 932              boss.show_employee();
 933         }
 934         Как видите, программа объявляет два объекта типа employee — worker и boss, а затем
 935  использует оператор точку (.) для присваивания значений элементам и вызова функции
 936  show_employee(). Еще раз вернитесь к заключительной части урока первого "Введение в
 937  ООП" и взяв в качестве примера последнюю программу подумайте - хорошо ли вы уяснили
 938  разницу между классом (employee) и объектом (worker,boss) от него порождаемым? Ну а
 939  итогом работы последней программы будет такой вывод на консоль:
 940         Имя: John Doe
 941         Номер служащего: 12345
 942         Оклад: 25000
 943         Имя: Happy Jamsa
 944         Номер служащего: 101
 945         Оклад: 101101
 946  
 947  Почти дословно с http://programmersclub.ru/21/ 
 948         Наконец, скажем пару слов о комментариях. Комментарии помогают человеку читать
 949  текст программы; писать их грамотно считается правилом хорошего тона. Комментарии
 950  могут характеризовать используемый алгоритм, пояснять назначение тех или иных
 951  переменных, разъяснять непонятные места. При компиляции комментарии выкидываются из
 952  текста программы поэтому размер получающегося исполняемого модуля не увеличивается.
 953         В С++ есть два типа комментариев. Один использует символы /* для обозначения
 954  начала и */ для обозначения конца комментария. Между этими парами символов может
 955  находиться любой текст, занимающий одну или несколько строк: вся последовательность
 956  между /* и */ считается комментарием. Например:
 957         /*
 958             * Первое знакомство с определением класса в C++.
 959             * Классы используются как в объектном, так и в
 960             * объектно-ориентированном программировании.
 961             */
 962         class Screen {
 963  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4   Страница 28 из 67
 964                  /* Это называется телом класса */
 965         public:
 966                  void home();         /* переместить курсор в позицию 0,0 */
 967                  void refresh (); /* перерисовать экран                                 */
 968         private:
 969                  /* Классы поддерживают "сокрытие информации"                    */
 970                  /* Сокрытие информации ограничивает доступ из                   */
 971                  /* программы к внутреннему представлению класса */
 972                  /* (его данным). Для этого используется метка                   */
 973                  /* "private:"                                                   */
 974                  int height, width;
 975         };
 976         Второй тип комментариев – однострочный. Он начинается последовательностью
 977  символов // и ограничен концом строки. Часть строки вправо от двух косых черт
 978  игнорируется компилятором. Вот пример того же класса Screen с использованием двух
 979  строчных комментариев:
 980  /*
 981           * Первое знакомство с определением класса в C++.
 982           * Классы используются как в объектном, так и в
 983           * объектно-ориентированном программировании.
 984           */
 985         class Screen {
 986                  // Это называется телом класса
 987         public:
 988                  void home();           // переместить курсор в позицию 0,0
 989                  void refresh (); // перерисовать экран
 990         private:
 991                  /* Классы поддерживают "сокрытие информации".                   */
 992                  /* Сокрытие информации ограничивает доступ из                   */
 993                  /* программы к внутреннему представлению класса */
 994                  /* (его данным). Для этого используется метка                   */
 995                  /* "private:"                                                   */
 996                  int height, width;
 997  Академия АйТи           Установка и администрирование ПСПО. Лекции. Часть 4   Страница 29 из 67
 998         };
 999  
1000  
1001         После того как программа на C++ создана (т.е. мы закончили редактировать файл с ее
1002  исходным текстом) следует важный этап - этап компиляции. Как уже было сказано, на этом
1003  этапе программа переводится из C++ языка в машинный (двоичный) код. Непосредственно
1004  сам процесс сильно варьируется от того используем ли мы среду разработки (и какую) или
1005  нет. Но даже если мы ее не используем компиляция будет запускаться и протекать по-
1006  разному в зависимости от платформы и используемого компилятора. Дело в том, что нет
1007  единого и универсального компилятора C++. Под каждую платформу есть свой компилятор,
1008  и не один. Так что в общем случае выбор нужного и подходящего варианта является
1009  прерогативой разработчика. Однако общая последовательность шагов этого процесса
1010  остается неизменной для всех компиляторов:
1011                  ·   запустить компилятор и указать в качестве входного файла наш файл с
1012          исходным текстом
1013                  ·   в случае отсутствия ошибок компиляции "забрать" (т.е. просто найти на
1014          локальном диске в выходной директории) выходной файл представляющий
1015          исполнимый модуль готовый к запуску на данной платформе
1016         Например, если мы сохранили исходный текст в файле FIRST.CPP а в качестве
1017  компилятора выбрали Borland C++ на платформе MS-DOS, то мы бы задали такую команду:
1018         C:\>BCC FIRST.CPP
1019         где BCC - как раз программа-компилятор. После нажатия на Enter мы могли бы
1020  проанализировать сообщения компилятора и в случае отсутствия синтаксических ошибок у
1021  нас на диске C: был бы размещен файл FIRST.EXE - результат работы компилятора. Запуск
1022  этого последнего файла привел к исполнению всей нашей программы.
1023         Однако использование сред разработок освобождает нас от набора консольных команд
1024  и предоставляет отчет о ходе и результате процесса компиляции в гораздо более удобном для
1025  анализа формате чем строчки в консоли. Это одно из многочисленных преимуществ таких
1026  сред вообще и KDevelop как одного из представителей в частности.
1027  
1028  2.2. Работа со средой разработки ПО KDevelop
1029         Итак, если мы чувствуем себя уверено в создании C++ программ и уже попробовали
1030  их писать и компилировать вне среды разработки, самое время обратиться к KDevelop и
1031  выяснить - как он может повысить эффективность работы по созданию ПО и облегчить
1032  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4   Страница 30 из 67
1033  процесс создания таких программ? Напомню, что приемы работы с рассматриваемым
1034  приложением от конкретного языка программирования не зависят, а C++ был выбран нами
1035  исключительно в силу его популярности. Поэтому все методики и приемы, обсуждаемые в
1036  этом подразделе, будут не менее полезны и применимы при создании Pascal-, Фортран-, Perl-
1037  и прочих программ из списка языков приведенного в начале текущего урока.
1038         Есть несколько способов запустить среду разработки KDevelop, однако если мы
1039  собираемся разрабатывать программу именно на C++ оптимальным будет путь через главное
1040  меню КДЕ-Прочие-Разработка-KDevelop-Среда разработки на C/C++ (Kdevelop: C/C++).
1041  При первом запуске нам будет показан «Совет дня» и мы можем указать - предъявлять ли
1042  его при каждом запуске или нет. Наконец, мы оказываемся в пустом рабочем пространстве
1043  (workspace), Рис. 1.
1044  
1045  
1046  
1047  
1048         Рис. 1. Пустое рабочее пространство среды KDevelop
1049  
1050  
1051  
1052  
1053  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4   Страница 31 из 67
1054         Именно в таком состоянии мы будем видеть среду не часто. Обычно после запуска
1055  будет автоматически открываться последний проект над которым мы работаем.
1056         Именно в пустом рабочем пространстве у нас альтернатив не много - мы можем либо
1057  открыть один из существующих проектов, либо начать проект новый. И то, и другое делается
1058  через меню Проект. Именно тут мы можем вызвать или пункт «Создать проект…» или
1059  «Открыть проект…». При старте нового проекта мы попадаем в мастер «Новый проект» и
1060  нам предстоит пройти несколько шагов. Самый важный, пожалуй, шаг первый, где мы
1061  выбираем шаблон будущего проекта. Давно было замечено, что средний разработчик начиная
1062  работать над тем, что по итогу станет новым консольным приложением обычно в качестве
1063  отправной точки использует один набор файлов, причем и содержимое этих файлов очень
1064  типично. Разумеется, по мере разработки эти файлы очень видоизменяются и становятся
1065  совсем не похожи на то, с чего все началось, однако начало-то у всех было одинаковым! То
1066  же можно сказать о разработке программ с графическим интерфейсом пользователя (GUI).
1067  Все GUI-программисты начинают примерно одинаково, и только по мере разработки у
1068  одного получается Калькулятор, а у другого Блокнот. Т.о. можно предположить, что всем
1069  разработчикам однотипных (консольных, графических, библиотечных и т.д.) приложений
1070  требуется одна и та же (но отличная от приложений другого типа) точка старта. Шаблон и
1071  есть эта самая точка, т.е. набор файлов предопределенного содержания. И выбор этот
1072  предстоит сделать в первом шаге мастера. Причем выбор является "многоуровневым".
1073  Сначала мы выбираем язык программирования (вспомним, что KDevelop является средой
1074  мультиязычной), затем, возможно, набор близких по назначению шаблонов и уже в нем -
1075  шаблон конкретного типа. При этом в правой части мастера нам покажут внешний вид
1076  целевого приложения и краткое описание шаблона, Рис. 2.
1077  
1078  
1079  
1080  
1081  Академия АйТи         Установка и администрирование ПСПО. Лекции. Часть 4   Страница 32 из 67
1082         Рис. 2. Шаг первый мастера нового проекта, выбор шаблона.
1083         В нашем курсе мы будем придерживаться шаблона находящегося в папке, разумеется,
1084  C++ и имеющего имя Простая программа Hello world. Этот проект является прекрасной
1085  отправной точкой для создания консольного приложения.
1086         На том же первом шаге мастера мы должны указать вторую важную информацию - где
1087  (в каком каталоге) разместятся файлы нашего проекта. Для этого предназначено поле Имя
1088  приложения. Здесь мы указываем, фактически, корневую папку проекта и по мере работы над
1089  последним она будет наполняться файлами и подкаталогами. Одновременно с этим и все
1090  наше приложение будет называться так же. Т.е. если мы введем сюда MyConsole, то:
1091                  ·   корневая папка проекта будет названа MyConsole
1092                  ·   исполнимый модуль (то, что получается в результате успешной
1093          компиляции проекта) будет иметь то же самое имя, только KDevelop приведет все
1094          буквы в его имени к нижнему регистру - myconsole. Именно этот модуль нужно
1095          запускать для того что бы увидеть нашу программу в работе. При этом найти на его
1096          диске можно будет по пути MyConsole/debug/src.
1097         На вопрос «где на диске искать саму корневую папку MyConsole» отвечает еще одно
1098  поле ввода на том же первом шаге - Расположение. По умолчанию MyConsole станет
1099  подкаталогом домашней папки (/home/admin/, если мы логинились как admin) но мы можем
1100  этот путь изменить. В любом случае в поле «Конечное расположение» мы увидим полный
1101  путь к корневой папке нашего проекта, например /home/admin/MyConsole и можем быть
1102  уверены - все, что имеет хоть какое-то отношение к нашему проекту (файлы исходного кода,
1103  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4   Страница 33 из 67
1104  заголовочные файлы, финальные исполнимые файлы и т.д.) будет расположено или в этой
1105  папке или в одной из ее подпапок.
1106         Наконец мы можем пробежаться по оставшимся шагам мастера и, для целей нашего
1107  курса, просто принять значения по умолчанию. Правда с одним исключением - шаг второй не
1108  даст нам перейти к шагу, следующему пока в поле Автор, не будет введено хоть какое-то
1109  значение. А вот все остальные шаги можно действительно "пролистать" нажатием кнопки
1110  Вперед.
1111         По окончанию мастера будет открыто окно редактора с текстом главного метода
1112  (Main). Это и есть отправная точка, предложенная нам выбранным шаблоном.
1113         Со всех сторон (кроме верхней) окна редактора располагаются множество ярлычков
1114  (т.н. табов) вспомогательным окон. Их порядка полутора-двух десятков и вопрос назначения
1115  каждого оказывается за рамками нашего курса. Скажем лишь об одном из важнейших -
1116  Сообщения. Его ярлычок первый в нижнем ряду ярлыков. Именно в этом окне появляются
1117  сообщения от компилятора и мы узнаем о допущенных в исходном тексте ошибках. Любое из
1118  вспомогательных окон (Сообщения в т.ч.) открывается/закрывается простым щелчком по
1119  соответствующему ярлычку.
1120         Обычно даже несложная C++ программа состоит из нескольких файлов исходного
1121  кода, причем есть 2 типа таких файлов - т.н. .cpp-файлы и т.н. .h-файлы.. Изначально
1122  выбранный нами шаблон Простая программа Hello world создает проект содержащий всего
1123  один файл по имени <имя_проекта>.cpp (например myconsole.cpp). Его наличие и
1124  необходимость не обсуждается, т.к. он содержит «точку входа» нашей программы - метод
1125  Main. Если же мы хотим добавить новые файлы (а чаще всего мы захотим это сделать) то
1126  следует воспользоваться диалогом вызываемом из меню Проект-Создать класс. Обычно
1127  проекты строятся по схеме 1 класс-1 логический файл, поэтому желание добавить новый
1128  файл почти всегда означает желание добавить новый класс и наоборот. А почему файл
1129  логический? Потому что в C++ класс принято объявлять и реализовывать в разных файлах
1130  (как раз те самые .h/.cpp файлы). Поэтому добавление 1 класса означает добавление двух
1131  физических файлов, хотя решают они совместными усилиями одну задачу, объявить и
1132  предоставить доступ к новому типу (классу) в нашей программе.
1133         Диалог «Новый класс» имеет 3 вкладки и изрядное количество различных опций и
1134  настроек, хотя по минимуму достаточно в поле Имя ввести имя нового класса. Тогда после
1135  нажатия кнопки OK будут созданы два файла - <имя_класса>.cpp и <имя_класса>.h - и оба
1136  
1137  Академия АйТи         Установка и администрирование ПСПО. Лекции. Часть 4   Страница 34 из 67
1138  они будут открыты для редактирования в своих закладках редактора. Переключаться между
1139  редактируемыми файлами можно щелчком по заголовкам (ярлыкам) этих закладок, причем
1140  «активная» вкладка будет «приподнята» над своими соседями Рис. 3.
1141  
1142  
1143  
1144  
1145         Рис. 3. Можно редактировать несколько файлов исходного кода одновременно. В
1146  настоящий момент редактируется файл myclass.h.
1147         Разумеется, редактор встроенный в среду KDevelop отвечает всем функциональным
1148  возможностям ожидаемым от серьезного продукта - перемещение, выделение, отступы,
1149  настраиваемые поиск/замена и т.д. Однако одна особенность заслуживает особенного
1150  упоминания. Допустим мы задекларировали 2 переменных
1151         int my_var1,my_var2;
1152         и теперь готовы присвоить значение 5 одной из них. Конечно мы можем полностью
1153  набрать
1154         my_var1=5;
1155         но можно и воспользоваться обсуждаемой возможностью редактора, а именно:
1156  набрать часть (2-3 символа, допустим my_) имени переменной и нажать Ctrl+J (или, что
1157  эквивалентно, выбрать в меню Правка-Завершить текст). Результат последовательности
1158  таких действий приведен на Рис. 4.
1159  
1160  
1161  
1162  
1163         Рис. 4. Одна из многочисленных особенностей редактора исходного кода среды
1164  KDevelop - Завершить текст.
1165  
1166  
1167         Остается лишь выбрать имя нужной переменной, и оно будет вставлено в исходный
1168  текст. Причем подсказка дается не только по именам переменных / методов, но и по
1169  ключевым словам C++.
1170  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4   Страница 35 из 67
1171         Наконец когда мы закончим набор исходных текстов всех файлов составляющих наш
1172  проект мы, разумеется, захотим нашу программу собрать (скомпилировать) и опробовать ее в
1173  работе. Компиляция проекта запускается через меню Сборка-Собрать проект или просто по
1174  нажатию F8. Для сборки проекта в среде KDevelop последней требуется особый файл - т.н.
1175  Makefile. Он нужен для автоматизации процесса компиляции нашего проекта и должен быть
1176  создан лишь однажды, поэтому при самой первой компиляции KDevelop предложит его
1177  создать и лишь после этого перейдет непосредственно к компиляции. Все последующие
1178  компиляции будут пользоваться уже готовым Makefile и поэтому будут проходить
1179  значительно быстрее чем самая первая.
1180         Как уже упоминалось, все ошибки компиляции будут отображены в окне Сообщения.
1181  Когда же мы добьемся их отсутствия то у нас будет 2 пути опробовать нашу программу в
1182  работе. Во-первых, мы можем открыть Konsole, перейти в каталог, в котором был
1183  сгенерирован        выходной   исполнимый         модуль      (в    нашем       разбираемом    примере       -
1184  /home/admin/MyConsole/debug/src) и запустить приложение по его имени:
1185         ./myconsole
1186         Но есть второй способ значительно более удобный, особенно если мы уверены, что
1187  нам нужен «пробный запуск» нашего приложения после которого мы вернемся к его
1188  разработке в среде KDevelop. Способ этот сводится к одному из трех вариантов:
1189                  ·      выбору пункта меню Сборка-Выполнить программу
1190                  ·      нажатию Shift+F9
1191                  ·      нажатие кнопки на панели, Рис. 5
1192  
1193  
1194  
1195  
1196         Рис. 5. Кнопка выполнения программы после ее успешной компиляции.
1197         Результатом любого из этого действия будет открытие консоли «силами» KDevelop и
1198  запуск нашей программы в этой консоли. По окончании работы нашей программы эта
1199  консоль не «схлопывается» немедленно, а предлагает нам нажать для этого Enter. Такая
1200  предусмотрительность позволит нам просмотреть вывод нашей программы, даже если мы
1201  сами не озаботились созданием подобной «паузы перед окончанием».
1202         Завершим разговор о языке C++ и среде разработки программ на этом языке KDevelop
1203  предложением нескольких ссылок на ресурсы посвященным этим двум областям
1204  компьютерной науки:
1205  
1206  Академия АйТи             Установка и администрирование ПСПО. Лекции. Часть 4            Страница 36 из 67
1207         Официальный сайт проекта KDevelop
1208         http://www.kdevelop.org
1209         Учебник по KDevelop
1210         http://www.beginning-kdevelop-programming.co.uk
1211         Учебник по C++ для начинающих
1212         http://programmersclub.ru/main
1213  
1214  
1215         3. Разработка ПО с использованием Lazarus
1216         Lazarus — свободная среда разработки программного обеспечения. Иными словами
1217  тип и предназначение этого программного пакета полностью аналогично разобранному в
1218  предыдущем уроке пакету KDevelop. Но есть и существенное отличие. Если KDevelop
1219  изначально задумывался как мультиязычный (в смысле поддержки массы языков
1220  программирования), то Lazarus поддерживает всего один компилятор и, соответственно, язык
1221  именно этого компилятора. В данном случае речь идет о Free Pascal Compiler (FPC) -
1222  свободно распространяемом компилятора языка Паскаль с открытыми исходными кодами.
1223  Этот вариант языка совместим с широко известными вариантами того же языка Borland
1224  Pascal 7 и Object Pascal – Delphi, но при этом обладает рядом дополнительных возможностей,
1225  например, поддерживает перегрузку операторов. Сам компилятор этого языка (FPC) —
1226  кроссплатформенный инструмент, поддерживающий огромное количество платформ. Среди
1227  них DOS, Linux, MacOS(X) и Win32. Ну а Lazarus просто удобная графическая оболочка для
1228  работы с FPC. Его часто сравнивают с другой популярной интегрированной средой
1229  разработки ПО фирмы Borland - Delphi. Это сравнение совершенно справедливо, т.к. Lazarus
1230  предоставляет разработчику подобное Delphi окружение и, более того, поддерживает
1231  преобразование проектов Delphi.
1232         Как и в случае с Kdevelop, для профессиональной работы в среде Lazarus мы должны
1233  быть компетентны в двух областях:
1234                  ·   мы должны знать и уметь писать синтаксически корректные программы
1235          на языке Паскаль как таковом, причем желательно, что бы это был вариант языка
1236          поддерживаемый именно Free Pascal Compiler (FPC)
1237                  ·   мы должны знать Lazarus именно как приложение и уметь пользоваться
1238          предлагаемым им функционалом
1239         Рассмотрим эти вопросы последовательно в следующих двух подразделах.
1240  
1241  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4   Страница 37 из 67
1242         3.1. Основы языка программирования Pascal
1243         Снова ограничимся довольно скромной задачей - рассмотреть избранные базовые
1244  конструкции языка Pascal в том его варианте, который поддерживается компилятором FPC.
1245         Минимальной программой производящей какую-то активность будет примерно
1246  следующая:
1247         program Hello;
1248         begin
1249           writeln ('Hello, world.');
1250         end.
1251         Разберем ее построчно.
1252         program Hello;
1253         Любая программа на Паскале начинается ключевым словом program вслед за которым
1254  следует название данной конкретной программы. Целиком эта строчка называется
1255  заголовком.
1256         begin…end.
1257         Ограничивают собой раздел операторов и называются операторными скобками.
1258  Иными словами играют ту же роль что скобки фигурные в C++ программе. Все что находится
1259  между этими двумя зарезервированными словами есть сама программа. В Паскале программа
1260  состоит из операторов, причем есть операторы простые и операторы составные. Составной
1261  оператор состоит из нескольких простых операторов и ограничен как раз операторными
1262  скобками begin и end. Т.о. разбираемая нами минимальная программа состоит из одного
1263  оператора. Операторы как и в C++ разделяются точкой с запятой. За телом всей программы
1264  должна следовать точка — признак того, что здесь находится конечная точка останова
1265  программы. Обратите внимание на "end." с точкой в конце - это именно требование языка.
1266         writeln ('Hello, world.');
1267         Как мы уже выяснили - это единственный оператор нашей программы. Он просто
1268  выводит указанную строку на консоль. Любая программа на Паскале состоит из множества
1269  операторов.
1270         Мы посмотрели описания заголовка и раздела операторов. Без них обычная программа
1271  на Паскале в принципе не возможна. В целом ряд программ могут быть созданы только с их
1272  помощью. Однако есть и другие составные блоки, используемые при написании программ, и
1273  поэтому общую структуру Pascal-программы принято выражать примерно такой схемой:
1274  
1275  Академия АйТи              Установка и администрирование ПСПО. Лекции. Часть 4   Страница 38 из 67
1276         PROGRAM ProgramName;
1277  
1278  
1279         CONST
1280              (* Декларация констант *)
1281  
1282  
1283         TYPE
1284              (* Декларация типов *)
1285  
1286  
1287         VAR
1288              (* Декларация переменных *)
1289  
1290  
1291         (* Определение процедур и функций *)
1292  
1293  
1294         BEGIN
1295              (* Тело программы *)
1296         END.
1297  
1298  
1299         Блоки PROGRAM и BEGIN…END. нам известны. Остальные блоки несут такую
1300  нагрузку:
1301         CONST - представляет раздел описания констант. Константа в программировании —
1302  это способ адресования к данным, изменение которых рассматриваемой программой
1303  запрещено. Использование констант, особенно, именованных — мощный инструмент,
1304  повышающий надёжность и безошибочность программ. Т.е. если в нашей программе
1305  постоянно используется в алгоритмах число 3.14 (приближенное значение широко известной
1306  математической константой "пи") то вместо того, что бы из раза в раз набирать эти три
1307  цифры с риском ошибиться, поставить десятичную точку не там или просто забыть о ней мы
1308  можем писать просто - PI. Или myPI. Или даже primernoPI. Это уж какое символьное имя мы
1309  сами присвоим числу 3.14. А выбор этого имени и непосредственное его связывание с
1310  конкретным значением как раз происходит в обсуждаемом блоке.
1311         В общем виде раздел описания констант выглядит так:
1312         Const
1313         <имя>=<значение>; ... ; <имя>=<значение>;
1314         Конкретный пример этого раздела:
1315  Академия АйТи         Установка и администрирование ПСПО. Лекции. Часть 4   Страница 39 из 67
1316         Const
1317         Nmin = 0; Nmax = 100; SIMV = 'начало';
1318         Заметим кстати, что если в качестве символьного имени числа «пи» нас устраивает
1319  строчка Pi - то ее объявлять не нужно. Компилятор Паскаля обладает «встроенным знанием»
1320  о том, что все вхождения строчки Pi должны быть заменены числом 3,14159… . Иными
1321  словами это одна из «системных» констант. Но, как было показано, мы можем объявить
1322  любое число своих собственных констант.
1323         TYPE - в этом разделе описывают нестандартные типы данных, образованные
1324  программистом. Что значит "нестандартные"? Таблица 3 приводит описание простейших
1325  типов языка Pascal.
1326  
1327  
1328         Имя типа               Характеристика типа
1329         BYTE                   целое число от 0 до 255, занимает одну ячейку памяти (байт).
1330         BOOLEAN                логическое значение (байт, заполненный единицами, или нулями),
1331                        true, или false.
1332         WORD                   целое число от 0 до 65535, занимает два байта.
1333         INTEGER                целое число от –32768 до 32767, занимает два байта.
1334         LONGINT                целое число от –2147483648 до 2147483647, занимает
1335                        четыре байта.
1336  
1337  
1338         REAL                   число с дробной частью от 2.9*10-39.до 1.7*1038, может
1339                        принимать и отрицательные значения, на экран выводится с точностью
1340                        до 12-го знака после запятой, если результат какой либо операции с
1341                        REAL меньше, чем 2.9*10-39, он трактуется как ноль. Переменная типа
1342                        REAL занимает шесть байт.
1343         DOUBLE                 число с дробной частью от 5.0*10-324.до.1.7*10308, может
1344                        принимать и отрицательные значения, на экран выводится с точностью
1345                        до 16-го знака после запятой ,если результат какой либо операции с
1346                        DOUBLE меньше, чем 5.0*10-324, он трактуется как ноль. Переменная
1347                        типа DOUBLE занимает восемь байт.
1348         CHAR                   символ, буква, при отображении на экран выводится тот символ,
1349                        код которого хранится в выводимой переменной типа CHAR, переменная
1350  
1351  Академия АйТи             Установка и администрирование ПСПО. Лекции. Часть 4   Страница 40 из 67
1352                        занимает один байт.
1353         STRING                 строка символов, на экран выводится как строка символов, коды
1354                        которых хранятся в последовательности байт, занимаемой выводимой
1355                        переменной типа STRING; в памяти занимает от 1 до 256 байт – по
1356                        количеству символов в строке, плюс один байт, в котором хранится
1357                        длина самой строки.
1358  
1359  
1360         Таблица 3. Простейшие типы, определенные в языке Pascal.
1361         Так вот все типы из последней таблицы описывать в обсуждаемом блоке не нужно.
1362  Ими можно просто пользоваться - объявлять переменные такого типа и т.д. Однако в Паскале
1363  разрешено введение новых типов определяемых программистом. Их описание происходит
1364  как раз в обсуждаемом блоке. В общем виде раздел описания типов выглядит так:
1365         Type
1366         <имя>=<тип>;
1367         ...
1368         <имя>=<тип>;
1369         Конкретный пример этого раздела:
1370         Type
1371         LatBukva = 'a'..'z';
1372         Dni = 1..31;
1373         В этом примере описаны два перечислимых типа: тип LatBukva, состоящий из
1374  символов латинского алфавита, и тип Dni, состоящий из целых зчисленных значений в
1375  диапазоне от 1 до 31. В этом же блоке объявляются «строительные кирпичики» ООП -
1376  классы.
1377         VAR - блок описаний переменных. Каждая встречающаяся в программе переменная
1378  должна быть описана. В общем виде раздел описания переменных выглядит так:
1379         Var
1380         <имя >, ... ,<имя >:<тип>;
1381         ...
1382         <имя >, ... ,<имя >:<тип>;
1383         Иными словами после ключевого слова VAR мы через запятую перечисляем
1384  однотипные переменные которые мы планируем использовать в программе, далее через
1385  
1386  Академия АйТи             Установка и администрирование ПСПО. Лекции. Часть 4   Страница 41 из 67
1387  двоеточие указываем тот или иной тип (причем тип может быть взят как из таблицы 3.3 так и
1388  из секции TYPE) и ставим точку с запятой. Повторяем все тоже самое для следующей группы
1389  однотипных переменных.
1390         Конкретный пример этого раздела:
1391         Var
1392         a, b, c, x, nomer: integer;
1393         y, z, result: real;
1394         В разделе описания переменных обычно описывают также массивы. Пример описания
1395  одномерного массива из пятидесяти элементов:
1396         Var a:array[1..50] of real;
1397         Или, что тоже самое, но с привлечением константы:
1398         Const Nmax = 50;
1399         Var a:array[1..Nmax] of real;
1400         Если предположить, что мы ранее описали блок TYPE таким образом:
1401         Type
1402         Month = (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);
1403         (т.е. Month есть тип состоящий из 12-ти предопределенных значений), то блок VAR
1404  можно объявить так:
1405         Var
1406         M: Month;
1407         (т.е. в переменную M можно поместить одно из 12-ти предопределенных значений).
1408         После объявления переменной в данном разделе ей можно присвоить какое-то
1409  значение в теле программы (или процедуры, или функции):
1410         variable_name := expression;
1411         Т.е. оператор присваивания в Паскале - двоеточие и знак равно. Примеры
1412  (предполагаем, что переменная some_real уже объявлена):
1413         some_real := 385.385837;
1414         some_real := 37573.5 * 37593 + 385.8 / 367.1;
1415         Как можно видеть к переменным и числовым константам применимы ожидаемые в
1416  любом языке программирования базовые арифметические операторы: +,-,*,/, mod (остаток от
1417  деления).
1418  
1419  
1420  
1421  Академия АйТи                Установка и администрирование ПСПО. Лекции. Часть 4   Страница 42 из 67
1422         Блок, который в схеме выше условно обозначен комментарием (* Определение
1423  процедур и функций *) на самом деле состоит из двух подсекций. Секции маркируемой
1424  ключевым словом PROCEDURE и секции с ключевым словом FUNCTION. Обе эти
1425  подсекции описывают подпрограммы, причем именно подпрограммы определяемые
1426  программистом. Паскаль предлагает изрядное количество стандартных процедур и функций
1427  и их описывать не требуется, ими можно просто пользоваться (вызывать). Примеры
1428  стандартных процедур:
1429                  ·   ClrScr – очистка экрана, курсор перемещается в верхний левый угол.
1430                  ·   Delay(t) – задержка программы на t миллисекунд.
1431                  ·   GotoXY(x,y) – перемещение курсора в точку с координатами (x,y).
1432                  ·   Exit – выход из текущего блока или из программы.
1433         Нестандартные процедуры и функции должны быть описаны. Их структура (т.е.
1434  описание), в принципе, такая же, как и основной программы, однако, прежде всего, следует
1435  уяснить разницу между процедурой и функцией, причем эта разница одинаково применима и
1436  к их стандартным разновидностям, и к определяемым программистом.
1437         Процедура - это обычная подпрограмма в самом широком смысле этого термина. Т.е.
1438  это подпрограмма, которая обрабатывает данные, принимает или выводит информацию,
1439  меняет или нет каким-либо образом глобальные и локальные переменные, вообще "что-то
1440  делает".
1441         Функция, это тоже подпрограмма, которая, как и процедура, что-то делает, но, помимо
1442  этого, она обязательно возвращает значение, тип которого задается при описании заголовка
1443  процедуры. Вызов функции является одним из допустимых операндов выражения, обозначая
1444  в нём то значение, которое вычисляет функция, то есть, если подпрограмма с
1445  идентификатором «Function1» – функция, то можно произвести следующие действия и
1446  записать такие операторы:
1447         X:=Function1(a,d,l,n,…);
1448         X:=2*Function1(a,e,…,m,…) - 1/Function1(c,f,…,k,…);
1449         Если бы Function1 была объявлена как процедура, и ее идентификатор был бы изменен
1450  на «Proc1» ее можно было бы только вызвать, но НЕ использовать в выражении:
1451         Proc1(a,e,…,m,…);
1452  
1453  
1454  
1455  
1456  Академия АйТи           Установка и администрирование ПСПО. Лекции. Часть 4   Страница 43 из 67
1457         Каждая объявляемая нами процедура/функция является «программой в программе»
1458  (потому их и называют подпрограммами). Вот пример объявления процедуры по имени Print.
1459  а затем ее вызова в теле главной программы:
1460         program Procedures;
1461         procedure Print(s: String; i: Integer);
1462         begin
1463           Writeln(s);
1464           Writeln(i);
1465         end;
1466  
1467  
1468         begin
1469           Print('Hello',3);
1470         end.
1471         А теперь пример объявления и вызова функции Add:
1472         program Functions;
1473  
1474  
1475         var
1476           Answer: Integer;
1477  
1478  
1479         function Add(i, j:Integer): Integer;
1480         begin
1481           Add := i + j;
1482         end;
1483  
1484  
1485         begin
1486           Answer := Add(1,2); {вызов ф-ии Add}
1487           Writeln(Answer);
1488           Writeln(Add(7,11)); {второй вызов ф-ии Add}
1489         end.
1490  
1491  
1492         Итак, мы разобрали основные структурные блоки Паскаль-программы. Отметим, что
1493  любой раздел описания (CONST, TYPE, VAR, PROCEDURE, FUNCTION) может
1494  
1495  Академия АйТи                Установка и администрирование ПСПО. Лекции. Часть 4   Страница 44 из 67
1496  отсутствовать. Т.е. если не планируем объявлять ни одной своей собственной функции, то
1497  просто не используем блок FUNCTION. Разделы описаний следуют в произвольном порядке.
1498  Каждый раздел описаний может использоваться любое число раз. После всех разделов
1499  описания следуют операторные скобки begin…end ограничивающие тело программы.
1500  
1501  
1502         Нам осталось выяснить вопрос приложимости                       ООП-принципов к Паскаль-
1503  программам. Т.е. как мы можем объявить класс (модель реального объекта) и как из класса
1504  получить новый его экземпляр.
1505         Класс в Паскале описывается как новый тип (и поэтому его описание вполне
1506  ожидаемо размещается именно в блоке TYPE) по примерно такой схеме:
1507         type <имя объекта>=object
1508           <список имён полей>: <тип полей>;
1509           ....
1510           <список имён полей>: <тип полей>;
1511           <объявление метода>
1512           ...
1513           <объявление метода>
1514         end;
1515         Вполне ожидаемая структура - тип, инкапсулирующий свои атрибуты (поля) и свой
1516  функционал (методы). Почти, как и в C++. Но есть и существенная разница - тела методов в
1517  объявлении класса не реализуются. Указываются только их (методов) заголовки, а
1518  реализация идет после описания типа:
1519         procedure <имя объекта>.<имя метода>(<параметры>)
1520         <тело процедуры>
1521         Обратите внимание на оператор точка (.). Аналогично можно описать и метод-
1522  функцию.
1523         Приведём    реализацию      объекта     "окно"     (объект     хорошо   всем     знакомый          по
1524  операционной системе Windows). Мы можем считать, что окно на дисплее задаётся
1525  координатами левого верхнего угла и размерами по горизонтали и вертикали, а также оно
1526  должно иметь флаг видимости (true означает, что окно на экран выведено).
1527         Type CWindow=object
1528           x,y:   integer; {координаты окна}
1529  
1530  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4            Страница 45 из 67
1531           lenx,leny: integer; {размеры окна}
1532           visible: boolean; {флаг видимости}
1533           procedure Init (_x,_y,_lenx,_leny: integer);
1534           procedure Show;
1535           function isVisible: boolean;
1536         end;
1537         procedure CWindow.Init (_x,_y,_lenx,_leny: integer);
1538         {Задаёт начальные параметры окна}
1539         begin
1540           Self.x:=_x;
1541           Self.y:=_y;
1542           Self.lenx:=_lenx;
1543           Self.leny:=_leny;
1544           visible:=true;
1545         end;
1546  
1547  
1548         procedure CWindow.show;
1549         {Рисует окно}
1550           var i,j: integer;
1551         begin
1552           visible:=true;
1553           {Остальная часть реализации процедуры опущена}
1554         end;
1555  
1556  
1557         function CWindow.isVisible: boolean;
1558         begin
1559           isVisible:=visible;
1560         end;
1561         Еще раз обратите внимание на вынос тел процедур и функций (методов) за границы
1562  определения класса. Более того, специальные компоновочные юниты (вспомогательные
1563  файлы кода), где и принято объявлять новые типы, требуют еще разнести объявление и
1564  
1565  
1566  
1567  Академия АйТи                Установка и администрирование ПСПО. Лекции. Часть 4   Страница 46 из 67
1568  реализацию методов по разным секциям внутри юнита. Мы поговорим о юнитах и об их двух
1569  главных секциях чуть позже.
1570         Создать объект нового типа и воспользоваться заложенным в нем функционалом
1571  можно способом практически совпадающим с применением типов встроенных. Сначала
1572  объявим переменную (пусть ее имя будет просто Window) целевого типа:
1573         var Window: CWindow;
1574         А затем, в теле программы, обращаемся к ее полям и/или методам с привлечением
1575  оператора точка:
1576         begin
1577           Window.Init (20,5,40,10);
1578           Window.Show;
1579         end.
1580         При написании проектов уровня хотя бы выше элементарного описание классов
1581  принято выносить в отдельный (от файла непосредственно программы) файл. В Паскале
1582  такие «вспомогательные» файлы называются юнитами (units) или, что тоже самое, модулями.
1583  Файл же содержащий текст самой программы так и будет называться - программа, и будет
1584  начинаться ключевым словом program, как это было показано в примерах выше. Файлы-
1585  юниты будут начинаться другим ключевым словом - unit через пробел от которого будет
1586  записано имя этого юнита, а после него обязана находиться точка с запятой. Юниты обязаны
1587  состоять из двух частей:
1588                   ·   части декларативной; она начинается с ключевого слова interface;
1589                   ·   части       реализационной;         она      начинается    с   ключевого       слова
1590          implementation.
1591         Часть декларативная содержит объявления всех глобальных объектов модуля (типов,
1592  констант, переменных и подпрограмм), которые должны стать доступными основной
1593  программе и/или другим модулям. Т.е., например класс со всеми его полями/методами
1594  объявляется именно здесь. Однако тела этих методов, их код, будет и должен располагаться
1595  не здесь, а во второй секции - реализационной. Собственно это и есть ее предназначение -
1596  содержать тела процедур и функций, объявленных в interface части. Все описание юнита
1597  завершается словом end с непременной точкой после него. Т.о. абсолютно минимальный, но
1598  синтаксически корректный юнит по имени, скажем, a имеет вид:
1599         unit a;
1600  
1601  Академия АйТи             Установка и администрирование ПСПО. Лекции. Часть 4         Страница 47 из 67
1602         interface
1603         implementation
1604         end.
1605         Главная программа должна явно выразить свое намерение и желание воспользоваться
1606  теми типами, константами, переменными и т.д. что были объявлены и реализованы в том или
1607  ином модуле. Делает она это через раздел uses в своем заголовке:
1608         program testv;
1609         uses a;
1610         Var
1611         Z : Variant;
1612         I : integer;
1613         // остальные разделы описания
1614         begin
1615         // текст программы
1616         end.
1617         После такого объявления программа testv может использовать все идентификаторы и
1618  сущности объявленные /реализованные в модуле a.
1619         Традиционно завершим краткий обзор языка правилами написания комментария. FPC
1620  поддерживает целых 3 их варианта:
1621         (* Комментарий в старом стиле *)
1622         { Комментарий в стиле Turbo Pascal }
1623         // Комментарий в стиле Delphi. Все символы
1624         // до конца строки пропускаются компилятором.
1625         Первые два ограничиваются парами символов (* или { с одной стороны и *) или } с
1626  другой. Оба варианта позволяют писать многострочные комментарии. Комментарий стиля
1627  «две черты» полностью аналогичен своему «коллеге» из языка C++. Т.е. он начинается
1628  последовательностью символов // и ограничен концом строки.
1629         3.2. Работа со средой разработки ПО Lazarus
1630         Среда Lazarus запускается из главного меню: КДЕ-Прочие-Разработка-Lazarus.
1631  Открывшаяся в результате этого действия среда имеет вид довольно своеобразный и не
1632  типичный для современных оконных приложений. У Lazarus нет рабочего пространства (т.е.
1633  одного главного окна) в понятиях типичных RAD-сред. Его рабочее пространство состоит из
1634  
1635  Академия АйТи           Установка и администрирование ПСПО. Лекции. Часть 4   Страница 48 из 67
1636  независимых окон выполняющих какую-либо функцию (редактирование кода, вывод
1637  сообщений компилятора, просмотр структуры и состава текущего проекта и т.д.), см. Рис. 6.
1638  Независимость этих окон выражается в том, что каждое из них можно свернуть, закрыть,
1639  переместить, не оказывая никакого влияния на окна прочие. Стандартная системная
1640  комбинация клавиш Alt+Tab (переключение окон) тоже выбирает их и выносит на передний
1641  план по одному. «Условно главным» можно считать узкое окно под номером 1 на Рис. 6. Его
1642  закрытие приведет к окончанию работы всего приложения Lazarus. Все прочие окна, как уже
1643  было сказано, могут открываться/закрываться независимо. «Условно главное» окно содержит
1644  лишь меню среды и несколько панелей управления с привычными кнопками. Реальная работа
1645  программиста протекает в основном в окнах дополнительных, число которых довольно
1646  значительно. Рассмотреть работу и назначение каждого не представляется возможным в силу
1647  ограничения времени нашего курса, однако, несомненно, одним из самых востребованных
1648  дополнительных окон будет окно редактора исходного кода (номер 2 на Рис. 6). Оно имеет
1649  точно такой же «закладочный» дизайн что и редактор предыдущей среды - KDevelop. Ясно,
1650  что мы можем редактировать сразу несколько файлов входящих в наш проект. Редактор
1651  среды Lazarus умеренно-продвинут и обладает базовым набором функционала ожидаемого в
1652  редакторе подобного класса. В частности присутствует аналог функции Завершить текст
1653  среды KDevelop (см. «Работа со средой разработки ПО KDevelop»), только здесь он
1654  называется identifier completion (завершение идентификатора) и вызывается сочетанием
1655  клавиш Ctrl+Space после набора первых 2-3 символов имени переменной.
1656         Так же отметим еще одно вспомогательное окно - Сообщения (номер 3 на Рис. 6).
1657  Именно здесь мы увидим сообщения компилятора в ходе процесса компиляции нашей
1658  программы. В целом трех указанных окон достаточно для написания не сложных консольных
1659  приложений..
1660  
1661  
1662  
1663  
1664  Академия АйТи         Установка и администрирование ПСПО. Лекции. Часть 4   Страница 49 из 67
1665         Рис. 6. Рабочее пространство среды Lazarus. Выделены окна: 1 – «главное», 2 -
1666  редактор исходного кода, 3 - сообщений компилятора.
1667         Еще одно отличие рабочего пространства Lazarus от такого же в KDevelop - оно «не
1668  умеет» быть пустым. Т.е. Lazarus требует что бы постоянно был открыт какой-то проект.
1669  Если в последнем сеансе мы работали над проектом MyProj_01 и при запуске среды он
1670  найден на диске - MyProj_01 и открывается как рабочий проект. Если последний проект не
1671  найден или это просто первый запуск среды разработки - Lazarus создает проект сам. В
1672  качестве шаблона (о них см.. «Работа со средой разработки ПО KDevelop») выбирается
1673  шаблон приложения с графическим интерфейсом пользователя. Это разумно, т.к.
1674  большинство создаваемых приложений будут именно этого типа. Однако, как мы помним,
1675  это не тот тип проекта, который нужен нам в изучаемом курсе, и мы решили придерживаться
1676  шаблонов приложений консольного типа. Тогда этот созданный средой "на удачу" проект
1677  можно закрыть через меню Проект-Закрыть проект. Никаких следов на диске он не
1678  оставляет если только в открывшемся окне-предупреждении мы укажем пункт «Отбросить
1679  Академия АйТи         Установка и администрирование ПСПО. Лекции. Часть 4   Страница 50 из 67
1680  изменения». Если этот стартовый проект вообще не менялся, то и закрывается он безо всяких
1681  предупреждений. Появившееся вслед за этим еще одно окно предложит нам выбор из трех
1682  опций (Рис. 7). Назначение каждой очевидно.
1683  
1684  
1685  
1686  
1687         Рис. 7. Окно выбора варианта продолжения работы после закрытия активного проекта.
1688         После выбора в этом последнем окне опции «Создать новый проект» среда
1689  предложит нам окно диалога «Создать новый проект» (Рис. 8). Фактически мы выбираем
1690  шаблон для нашего приложения. Список имеющихся далеко не столь внушителен как у
1691  среды KDevelop, но достаточен для типовой разработки. Минималистическим шаблоном
1692  консольного приложения будет вариант «Программа пользователя» (Custom Program).
1693  Именно этот шаблон мы используем в практической части занятий.
1694  
1695  
1696  
1697  
1698         Рис. 8. Окно создания нового проекта. Выбор шаблона будущего приложения.
1699         После выбора этого варианта в редакторе будет открыт исходный текст единственного
1700  (пока) файла составляющего наш проект - project1. Этот файл содержит код главной
1701  программы (которая по умолчанию имеет тоже самое имя - Project1) к редактированию
1702  которого и можно приступать. Если программист желает добавить к проекту новые файлы (а
1703  в проектах реальных вероятность такого желания близка к 100%) то он может пойти
1704  несколькими путями, в зависимости от типа добавляемого файла. Мы воспользуемся путем
1705  самым прямолинейным – Файл-Создать модуль. Новый модуль (он же юнит, unit)
1706  добавляется к проекту и открывается в своей закладке редактора. По умолчанию он имеет
1707  Академия АйТи         Установка и администрирование ПСПО. Лекции. Часть 4   Страница 51 из 67
1708  имя Unit1, а в текст главной программы добавляется строка uses Unit1. Имя нового модуля,
1709  конечно, можно изменить прямо в редакторе.
1710         Что касается сохранений, то лучшей стратегией будет сохранение каждого нового
1711  модуля (а так же файла главной программы) непосредственно в момент их добавления к
1712  проекту и лишь затем переход к их редактированию. Для этого достаточно в любой момент
1713  выбрать пункт меню Файл-Сохранить как…. Данная команда воздействует на файл в
1714  активной закладке редактора. Пока это не сделано файл существует лишь в памяти
1715  компьютера и может быть в любой момент утерян. В ответ на выбор указанного пункта меню
1716  откроется диалог сохранения активного файла (Рис. 9).
1717  
1718  
1719  
1720  
1721         Рис. 9. Окно диалога сохранения файла/проекта.
1722  
1723  
1724         Здесь надо иметь в виду, что в отличии от среды KDevelop Lazarus самостоятельно не
1725  создает т.н. корневой папки проекта. А она очень удобна в плане управления файлами,
1726  входящими в наш проект. По счастью, из окна сохранения проекта (Рис. 9) мы такую папку
1727  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4   Страница 52 из 67
1728  можем создать самостоятельно, для этого предусмотрена кнопка Создать каталог. Новый
1729  каталог станет подпапкой каталога указанного в поле «Looking in». После создания желаемой
1730  корневой папки проекта остается перейти в нее двойным щелчком по ее имени в списке
1731  Каталоги и в поле Выбор: <полный_путь_до_ корневой_папки_проекта> ввести имя
1732  сохраняемого файла. При этом если мы сохраняем файл главной программы, то на диск в
1733  указанную папку запишутся 2 файла:
1734                  ·   с расширением .pas - непосредственно текст программы;
1735                  ·   с расширением .lpi - файл самого проекта
1736         Иными словами имена проекта и главной программы всегда совпадают. При
1737  сохранении же нового модуля (unit) на диск пишется одни файл, с расширением .pas и
1738  (возможно, но не обязательно) вносятся необходимые изменения в текст файла проекта. Т.о.
1739  созданная нами корневая папка проекта будет содержать все файлы необходимые
1740  программисту в работе. После успешной компиляции итоговый исполнимый модуль будет
1741  помещен сюда же.
1742         Желательно указывать имена всех файлов проекта в нижнем регистре дабы избежать
1743  предупреждения о возможных проблемах (Рис. 10). Впрочем, прямо из этого окна можно
1744  позволить среде привести имена к требуемому регистру. KDevelop выполняет подобный же
1745  «маневр» не интересуясь мнением разработчика.
1746  
1747  
1748  
1749  
1750         Рис. 10. Окно предупреждения о регистре имени проекта.
1751         Когда все файлы отредактированы должным образом и сохранены на диск можно
1752  попробовать собрать программу. Процесс компиляции инициируется выбором пункта меню
1753  Запуск-Собрать или просто нажатием Ctrl+F9. Как уже отмечалось ход и результат этого
1754  процесса сообщается в особом окне - Сообщения (номер 3 на Рис. 6). После успешной
1755  компиляции возможен тестовый прогон свежей программы прямо из среды. Однако если
1756  KDevelop готов к подобному прогону «со старта», консоль, открываемую изнутри Lazarus
1757  нужно предварительно настроить. Диалог такой настройки вызывается через меню Запуск-
1758  Параметры запуска…. В открывшемся одноименном окне (Рис. 11) требуется:
1759  
1760  Академия АйТи         Установка и администрирование ПСПО. Лекции. Часть 4   Страница 53 из 67
1761                  ·       разрешить использовать внешнее приложение (консоль) для запуска
1762           нашей программы. За это отвечает флажок Использовать приложение для запуска;
1763                  ·       указать путь к этому внешнему приложению. По умолчанию таковым
1764           выступает xterm - стандартный эмулятор терминала для среды X Window System в
1765           Unix. остается лишь проверить правильность пути к нему.
1766           После всех этих настроек запуск откомпилированной программы проблем не
1767  составляет: Запуск-Запуск или просто F9. Должно открыться окно консоли в котором мы
1768  можем осуществлять ввод для нашей программы и/или наблюдать выводимую ей
1769  информацию. Точно так же как и в случае с KDevelop эта консоль не "схлопывается"
1770  немедленно по окончанию нашей программы, а любезно предлагает нам нажать для этого
1771  Enter.
1772           Традиционно завершим разговор о языке Pascal и среде разработки программ на этом
1773  языке Lazarus предложением нескольких ссылок на ресурсы посвященным этим двум
1774  областям компьютерной науки:
1775           Официальный сайт проекта Lazarus
1776           http://lazarus.freepascal.org
1777           Русскоязычный сайт с материалами по компилятору Free Pascal и среде Lazarus
1778           http://freepascal.ru
1779           Lazarus wiki - энциклопедия по Free Pascal Compiler/Lazarus
1780           http://wiki.lazarus.freepascal.org
1781           4. Разработка ПО с использованием Gambas
1782           Суть и предназначение третьего из рассматриваемых нами пакетов - Gambas -
1783  полностью аналогично двум предыдущим. Как и с KDevelop, и с Lazarus мы имеем дело с
1784  Rapid Application Development (RAD), т.е. со средой разработки программного обеспечения.
1785  По своим возможностям Gambas значительно ближе к Lazarus, т.к. настроен на поддержку
1786  всего одного языка. В данном случае речь идет о языке Basic с объектным расширением. Т.е.
1787  такой вариант языка начального уровня, который позволяет применять при разработке
1788  программ принципы ООП. Этот диалект языка Basic тоже называется Gambas. Т.о. слово
1789  Gambas одновременно обозначает И пакет облегчающий написание на " Basic-о подобном"
1790  языке, И сам этот язык. Собственно если разобрать слово Gambas то выясняется что это —
1791  рекурсивный акроним от англ. Gambas Almost Means BASic, что в дословном русском
1792  переводе выглядит как «Gambas Почти Означает Basic», а более привычно русскому уху:
1793  
1794  Академия АйТи               Установка и администрирование ПСПО. Лекции. Часть 4   Страница 54 из 67
1795  «Gambas — почти Basic». Само слово Gambas с испанского переводится как "креветка",
1796  которая изображена на логотипе обсуждаемого пакета.
1797         Gambas       задумывался     как    альтернатива       для     Microsoft   Visual     Basic     (MVB)
1798  разработчиков, решивших перейти на GNU/Linux. Действительно, программист на MVB
1799  сможет без труда переключиться на Gambas, но надо иметь в виду, что второй не является
1800  клоном первого и определенно не поддерживает запуск программ созданных в MVB.
1801         И снова, как и в случае двух предыдущих сред разработки, для профессиональной
1802  работы с Gambas мы должны быть компетентны в двух областях:
1803                  ·      мы должны знать и уметь писать синтаксически корректные программы
1804          на языке Basic и лучше, если это будет его вариант с объектным расширением.
1805          Разработчики, знающие Basic классический, получают заметное преимущество в этом
1806          аспекте обучения;
1807                  ·      мы должны знать Gambas именно как приложение и уметь пользоваться
1808          предлагаемым им функционалом.
1809         Рассмотрим эти вопросы последовательно в следующих двух подразделах.
1810         4.1. Основы языка программирования BASIC (ОО диалект)
1811         Традиционно начнем обзор базовых конструкций языка с примера программы близкой
1812  к минимальной:
1813         PUBLIC SUB Main()
1814                  DIM m AS Float
1815                  m=doMultiply()
1816                  PRINT m
1817         END
1818         PRIVATE FUNCTION doMultiply() AS Float
1819                  DIM x AS Float
1820                  DIM y AS Float
1821                  PRINT "Enter x:"
1822                  INPUT x
1823                  PRINT "Enter y:"
1824                  INPUT y
1825                  RETURN x*y
1826         END
1827  
1828  Академия АйТи             Установка и администрирование ПСПО. Лекции. Часть 4              Страница 55 из 67
1829         Что получится в результате запуска этой программы? На консоль будет выведено три
1830  строки - первая пригласит пользователя указать число x, вторая - y и третья просто выведет
1831  результат умножения этих двух чисел.
1832         Перейдем теперь к ее построчному разбору.
1833         PUBLIC SUB Main()
1834         Декларирует главный метод (точку входа) создаваемой программы. Отсюда начнется
1835  ее выполнение. Имя главного метода - Main. Вообще Gambas поддерживает декларацию двух
1836  разновидностей методов: процедур и функций. Разница между этими сущностями полностью
1837  аналогична разнице между ними же в языке Pascal, т.е. функция есть процедура
1838  возвращающая значение заданного типа. Поскольку данная декларация не включает
1839  ключевого слова AS можно сделать вывод, что декларируется именно процедура. Пример
1840  декларации функции будет приведен чуть ниже.
1841         DIM m AS Float
1842  Любая переменная, планируемая к использованию в пределах класса / процедуры / функции,
1843  должна быть предварительно декларирована. Переменные могут быть глобальными по
1844  отношению        к   классу   их    декларирующему           или     локальными          по    отношению          к
1845  процедуре/функции так же их декларирующих. Ключевое слово DIM необходимо именно для
1846  декларации локальных переменных. После этого слова идет имя переменной (или несколько,
1847  через запятую, если они все будут однотипны), за ним еще одно ключевое слово AS и,
1848  наконец, тип переменной. Какие типы можно указывать? Поскольку мы уже определили, что
1849  «Gambas=Basic+объектные расширения» то, разумеется, программист может создавать свои
1850  собственные типы (классы). Но и, конечно, Gambas предлагает встроенные, элементарные
1851  типы, которые описывать не нужно, а можно просто указывать после ключевого слова AS.
1852  
1853  
1854  Таблица 3.4 приводит такие типы, а точнее самые востребованные из них.
1855         Имя                Диапазон значений, комментарий                        Занимаемый          в     памяти
1856  типа                                                                  размер
1857         Boolean            true / false                                          1 байт
1858         Short              -32.768...+32.767                                     2 байта
1859         Integer            -2.147.483.648...+2.147.483.647                       4 байта
1860         Single             -1,7014118+38…+1,7014118E+38                          4 байта
1861         Date               Дата/время (например, 07/19/2005                      8 байт
1862  
1863  Академия АйТи             Установка и администрирование ПСПО. Лекции. Часть 4                 Страница 56 из 67
1864                   02:20:08) сохраненные в виде одного
1865                   целого числа
1866         String            Строчка символов переменной                           4   байта    (указатель         на
1867                   длины                                               строку) + память необходимая
1868                                                                       для       хранения    всех     символов
1869                                                                       строки
1870  
1871  
1872         После декларации локальные переменные могут быть использованы в любом месте
1873  только той процедуры/функции, что их декларировала. Переменная m в нашем примере
1874  доступна и "видна" только процедуре Main.
1875         m=doMultiply()
1876         Вызывается функция doMultiply и результат ее вызова присваивается только что
1877  задекларированной переменной m. Вызов процедур/функций в Gambas происходит по
1878  самому типичному шаблону всех языков: имя вызываемой процедуры/функции - круглые
1879  скобки - в скобках аргументы вызова через запятую. В данном случае функция doMultiply
1880  никаких аргументов не принимает и их список в данной строчке вызова пуст. Конечно, саму
1881  функцию doMultiply надо тоже декларировать и реализовать и мы вскоре увидим, как это
1882  делается.
1883         При декларации аргументов процедур / функций Gambas предлагает вариант их
1884  опционального применения при вызове. Осуществляется такой подход с привлечением
1885  ключевого слова OPTIONAL, например:
1886         PRIVATE SUB DoIt(sCommand AS String, OPTIONAL bSaveIt AS Boolean = TRUE)
188718881889         END
1890         Такая декларация говорит, что процедура DoIt может быть вызвана с одним (как
1891  минимум, т.к. первый аргумент является обязательным, а не опциональным) или с двумя
1892  аргументами. В первом случае (вызов с одним аргументом) DoIt считает, что во втором
1893  аргументе было передано значение TRUE.
1894         PRINT m
1895         Инструкция PRINT просто печатает на консоли выражение указанное после нее, в
1896  данном случае им станет переменная m содержащая результат умножения.
1897  
1898  Академия АйТи            Установка и администрирование ПСПО. Лекции. Часть 4               Страница 57 из 67
1899         END
1900         Закрывает описание (и завершает выполнение) процедуры/функции. Завершение
1901  главной процедуры Main так же означает окончание работы программы.
1902         PRIVATE FUNCTION doMultiply() AS Float
1903         Декларируем функцию doMultiply вызываемую из главной процедуры. То что это
1904  декларация именно функции (а не процедуры) говорит наличие ключевого слова AS.
1905  Функция обязана вернуть какое-то значение и тип указанный после этого ключевого слова
1906  говорит, какого типа это значение будет. В данном случае doMultiply имеет право вернуть
1907  любое число из диапазона значений типа Float (-8.98E+307…+8.98E+307).
1908         DIM x AS Float
1909         DIM y AS Float
1910         Декларируются две локальных (по отношению к функции doMultiply) однотипных
1911  переменных x и y. Могло бы быть для краткости записано и как
1912         DIM x,y AS Float
1913         PRINT "Enter x:"
1914         Печатает (в консоли) приглашение пользователю.
1915         INPUT x
1916         Принимает ввод пользователя и помещает его в указанную переменную.
1917         PRINT "Enter y:"
1918         INPUT y
1919         Аналогично x, но для переменной y
1920         RETURN x*y
1921         Заканчивает выполнение (но не описание!) функции doMultiply путем возврата в
1922  вызывающий код значения заданного типа (умножение одного Float на другой даст в
1923  результате еще один Float, а именно такой тип наша функция и обязана вернуть).
1924         END
1925         Закрывает описание функции.
1926         Как легко видеть из приведенного примера в Gambas (в отличии от тех же C++ /
1927  Pascal) каждая отдельная инструкция не обязана завершаться каким-либо спецсимволом
1928  вроде точки с запятой.
1929         К    числовым      переменным         и    константам       применимы    ожидаемые     базовые
1930  арифметические операторы: +,-,*,/, mod (остаток от деления), ^ (возведение в степень).
1931  
1932  Академия АйТи             Установка и администрирование ПСПО. Лекции. Часть 4       Страница 58 из 67
1933  Присвоение какого-либо значения переменной осуществляется простым знаком равенства,
1934  например:
1935         DIM N AS Integer
1936         DIM R AS Integer
1937         N = 3
1938         R = 6
1939         С помощью ключевого слова CONST поддерживается декларация констант:
1940         PUBLIC CONST MAX_VAL AS Integer = 30
1941         PUBLIC CONST HEADER AS String="# Gambas!!"
1942         После подобной декларации отрывок кода
1943         DIM b,p,t AS Integer
1944         b=1 + 30
1945         p=7 * 30
1946         t=(b+p) / 30
1947         может быть переписан как
1948         DIM b,p,t AS Integer
1949         b=1 + MAX_VAL
1950         p=7 * MAX_VAL
1951         t=(b+p) / MAX_VAL
1952         что гораздо практичнее, если мы предвидим возможное изменение значения
1953  константы MAX_VAL и особенно если такие изменения будут частыми.
1954         Нам осталось выяснить вопрос приложимости ООП-принципов к Gambas-программам.
1955  Т.е. как мы можем объявить класс (модель реального объекта) и как из класса получить
1956  новый его экземпляр. Здесь Gambas предлагает такой подход. Декларация нового класса
1957  начинается с создания нового файла специального назначения (реализуемого как просто
1958  новый файл на HDD содержащий удобную для начала работы с новым классом шаблон-
1959  заготовку). Для этого щелкните правой кнопкой мыши в окне проекта (подробнее об этом
1960  окне см. следующий раздел, «Работа со средой разработки ПО Gambas») и выберите New -
1961  Class (Новый - Класс). Вам будет предложено назвать новый файл и класс (т.е. имя файла и
1962  становится именем класса). Допустим, мы бы могли назвать этот файл Person, имея в виду,
1963  что мы приступаем к моделированию объекта реального мира - человека (персоны).
1964         Все место в новом файле отведено для одной задачи - описания полей (атрибутов) и
1965  процедур / функций (методов) нового класса. Начать мы бы могли с полей:
1966  Академия АйТи         Установка и администрирование ПСПО. Лекции. Часть 4   Страница 59 из 67
1967         ' Gambas class file
1968         PUBLIC firstname AS String
1969         PUBLIC surname AS String
1970         PUBLIC salary AS Float
1971         Как легко догадаться из декларации все три поля будут доступны и из кода нашего
1972  класса Person, и из кода любого другого класса / процедуры / функции. Это, конечно,
1973  нарушение одного из базовых принципов ООП (инкапсуляции) и мы идем на это только с
1974  целью максимально упростить пример для новой темы.
1975         После определения всех полей мы могли бы перейти к декларации и реализации
1976  методов. В любом создаваемом классе мы можем указать «особую» процедуру по имени
1977  _new. Эта процедура нужна для инициализации всех полей нашего класса и вызывается в
1978  момент создания его экземпляра. Вспомним, что метод, обладающий подобными
1979  характеристиками, называется конструктором, и наша _new-процедура представляет именно
1980  его:
1981         PUBLIC SUB _new(ifirstname AS String, isurname AS String, isalary AS Float)
1982                  firstname = ifirstname
1983                  surname = isurname
1984                  salary = isalary
1985         END
1986         И далее мы бы продолжили разработкой любого потребного функционала. В данном
1987  случае ограничимся единственной функцией рассчитывающей размер налога исходя из
1988  значения поля salary:
1989         PUBLIC FUNCTION tax() AS Float
1990                  DIM tsalary AS Float
1991                  DIM ttax AS Float
1992                  tsalary = salary
1993                  ttax = 0
1994                  ' сам расчет реализован здесь
1995                  RETURN ttax
1996         END
1997         После этого мы могли бы сохранить данный (новый файл) и вернуться в файл с
1998  главной процедурой Main. В ней мы могли бы написать примерно такой код:
1999         ' Gambas module file
2000  Академия АйТи              Установка и администрирование ПСПО. Лекции. Часть 4   Страница 60 из 67
2001         PUBLIC SUB Main()
2002             ' Декларация
2003             DIM p1 AS Person
2004             DIM p2 AS Person
2005             DIM tax1, tax2 AS Float
2006             ' Инициализация
2007             p1 = NEW Person("Jane", "Jones", 35000)
2008             p2 = NEW Person("Fred", "Smith", 23000)
2009             ' Использование
2010             tax1 = p1.tax()
2011             tax2 = p2.tax()
2012             PRINT tax1
2013             PRINT tax2
2014         END
2015         Здесь мы сначала декларируем 4 переменных: p1 и p2 будут переменными нового
2016  типа, а tax1 и tax2 являются переменными элементарного типа Float и нужны нам для
2017  сохранения рассчитанного для каждой персоны налога. Далее мы инициализируем две
2018  переменные типа Person. В завершении главная процедурой Main использует имеющийся в
2019  классе Person функционал расчета налога и запоминает результат в двух своих локальных
2020  переменных, содержимое которых и выводится на консоль двумя финальными инструкциями
2021  PRINT. Для обращения к методам того или иного объекта используется самый популярный
2022  для этой цели оператор - точка (.).
2023         И, по традиции, завершим краткий обзор языка правилами написания комментария.
2024  Тут все крайне не сложно - любая строчка начинающаяся знаком апострофа (') и до конца
2025  считается именно им. Уточним, что речь идет о кавычке-апострофе традиционно делящей на
2026  стандартной клавиатуре одну клавишу с кавычками двойными. Использование вместо него
2027  машинописного обратного апострофа (символ на одной клавише с тильдой, ~) будет
2028  расценено компилятором как ошибка. Многострочные комментарии (аналоги /* */ в C++) в
2029  Gambas отсутствуют.
2030         4.2. Работа со средой разработки ПО Gambas
2031         Как известно все RAD-среды имеют один и тот же базис и основываются на одних и
2032  тех же идеях. Везде будут шаблоны, проекты, файлы исходного кода и т.п. Везде будет
2033  главное меню с панелями ниже его и масса рабочих окон, открываемых/закрываемых по
2034  Академия АйТи           Установка и администрирование ПСПО. Лекции. Часть 4   Страница 61 из 67
2035  необходимости. Всюду можно скомпилировать исходный код, запустить его, отладить и т.п.
2036  Рассмотрение двух предыдущих сред разработки - KDevelop и Lazarus - лишь подтверждает
2037  этот факт.
2038         Никуда не деться из этой «генеральной колеи» и среде третьей - Gambas. Да, все тот
2039  же набор шаблонов для старта нового проекта, тот же «многозакладочный» редактор с
2040  характерным функционалом (в частности - на месте функция автозавершения имен
2041  идентификаторов, причем вам не нужно для ее вызова нажимать какую-то особую «горячую»
2042  клавишу; просто начните набирать имя переменной - спустя 3-4 символа появится окно со
2043  списком вариантов, Рис. 11), такая же возможность запустить разрабатываемое приложение
2044  (а нас снова будет интересовать их консольная разновидность) прямо из среды и провести
2045  анализ выводимой им информации и т.д.
2046  
2047  
2048  
2049  
2050         Рис. 11. Функция автозавершения имен в Gambas срабатывает автоматически.
2051  
2052  
2053         Поскольку все необходимые концепции и типовой функционал сред разработки нам
2054  теперь известны и понятны, рассмотрим еще одного их представителя - Gambas - в сжато-
2055  конспективном режиме. А именно: применим подход «Как мне…?», который максимально
2056  скупо дает ответ на один конкретный вопрос - как произвести то или иной действие - не
2057  погружаясь в нюансы. Необходимость того или иного действия и порядок их следования
2058  (например тот факт, что сначала надо создать проект и лишь затем переходить к
2059  редактированию кода), считаем, нам понятен из опыта работы с предыдущими двумя RAD-
2060  средами.
2061  
2062  
2063  Академия АйТи         Установка и администрирование ПСПО. Лекции. Часть 4   Страница 62 из 67
2064         Итак, таблица 3.5 приводит набор типичных «Как мне…?» действий требуемых для
2065  создания простого консольного приложения на языке BASIC, его компиляции и тест-прогона
2066  прямо из среды.
2067  
2068  
2069         Как мне….                     Предлагаемое действие
2070         …запустить среду              Выбрать в главном меню: КДЕ-Прочие-Разработка-
2071  Gambas?                      Интегрированная среда разработки Gambas (Gambas IDE)
2072         …начать     новый             Выбрать       пункт «Новый проект» в окне «Добро
2073  проект?                      пожаловать в Gambas II», появляющееся немедленно после
2074                               запуска среды
2075         …выбрать                      После выбора пункта «Новый проект» (см. предыдущий
2076  консольный            тип вопрос) будет предложен список из нескольких типов проектов
2077  проекта?                     (шаблонов). Один из них - Консольное приложение.
2078         …создать                      На шаге «2. Директория проекта» мастера создания
2079  корневую            папку нового проекта мы выбираем родительскую папку для будущей
2080  проекта?                     корневой папки проекта. Далее, на шаге «3. Информация о
2081                               проекте»      мы     указываем       имя        проекта.   В      результате       в
2082                               родительской папке создается одноименная подпапка. Эта
2083                               последняя и будет корневой папкой проекта.
2084         …добавить        к            Щелкнуть правой кнопкой мыши в любом месте окна
2085  проекту новые файлы?         проекта среды (окно 1, Рис. 12). Выбрать из контекстного меню
2086                               Новый-Модуль…. Это добавит файл где можно описывать и
2087                               реализовывать новые функции/подпрограммы, но не новые типы
2088                               (классы). Или, в том же меню выбрать Новый-Класс…. Это
2089                               добавит файл, где можно описывать и реализовывать новые
2090                               типы (классы).
2091         …перейти         к            Если файл с кодом уже открыт в окне редактора (окно 2,
2092  редактированию       того Рис. 12) то достаточно щелкнуть по закладке с именем файла.
2093  или       иного    файла Если требуемый файл пока закрыт, необходим будет двойной
2094  исходного            кода щелчок по его имени в окне проекта среды (окно 1, Рис. 12).
2095  входящего в проект?
2096         …сохранить                    Выбрать в главном меню среды Файл-Сохранить проект
2097  
2098  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4                  Страница 63 из 67
2099  внесенные           в     файлы или просто нажать Ctrl+Alt+S. Сохраняются сразу все файлы
2100  исходного                   кода проекта.
2101  изменения на диск?
2102         …запустить                           Выбрать в главном меню среды Проект-Компилировать
2103  компиляцию проекта?                 Все. «Быстрая клавиша» для этой команды - Alt+F7.
2104         …узнать                об            В отличии от других языков программирования файл
2105  ошибках         в       исходном исходного кода не воспринимается компилятором как единое
2106  коде и исправить их?                целое, а интерпретируется строка-за-строкой, сверху вниз.
2107                                      Первая      же       строка,    выходящая         за       рамки    понимания
2108                                      интерпретатора прерывает весь процесс компиляции и:
2109                                                       ·       закладка с файлом, содержащим ошибочный
2110                                              текст становится активной в окне редактора (окно 2, Рис.
2111                                              12);
2112                                                       ·       выводится дополнительное окно-сообщение
2113                                              с      описанием       ошибки;      для    продолжения             работы
2114                                              потребуется нажать OK в этом информационном окне;
2115                                                       ·       после нажатия на OK курсор редактора
2116                                              спозиционируется          на     строке        с   ошибкой,        можно
2117                                              приступать к ее исправлению и затем к новой попытке
2118                                              компиляции.
2119         …собрать                             Выбрать в главном меню среды Проект-Собрать-
2120  исполнимый модуль?                  Executable….         «Быстрая      клавиша»       для      этой    команды       -
2121                                      Ctrl+Alt+M.
2122         …запустить                           Добиться успешной компиляции проекта а затем выбрать
2123  разрабатываемое                     в главном меню среды Отладка-Старт. Тоже самое делает
2124  приложение          из     среды клавиша F5. Если проект еще не компилировался с момента
2125  разработки?                         последних изменений в файлах исходного кода, то сначала
2126                                      запускается этот процесс, а после его успешного завершения
2127                                      происходит старт приложения.
2128         …провести                            Окно консоли встроено прямо в среду разработки (окно 3,
2129  пробный сеанс работы с Рис. 12). Весь консольный вывод поступает сюда. Отсюда же
2130  разрабатываемым                     может       быть     осуществлен        пользовательский           ввод,     если
2131  
2132  Академия АйТи                 Установка и администрирование ПСПО. Лекции. Часть 4                Страница 64 из 67
2133  консольным приложением разрабатываемое приложение запрограммировано на таковой.
2134  не    выходя    из   среды
2135  разработки?
2136  
2137  
2138         Таблица 3.5. Типичные действия, совершаемые разработчиком в RAD-среде Gambas.
2139  
2140  
2141  
2142  
2143         Рис. 12. Окно среды разработки Gambas с консольным проектом, состоящим из трех
2144  файлов исходного кода.
2145         Из приведенной таблицы легко видеть, что все шаги действительно крайне характерны
2146  для прочих сред разработки и неоднократно выполнялись нами при изучении двух
2147  предыдущих пакетов, KDevelop и Lazarus. Недоумение может вызвать лишь наличие
2148  действия «компиляция» параллельно с действием «собрать исполнимый модуль». Разве одно
2149  не следует из другого? Разве после успешной компиляции исполнимый модуль не создается
2150  автоматически? Ответы на эти вопросы утвердительны для подавляющего числа
2151  компиляторов, но НЕ для компилятора с языка BASIC (и его ближайшего «родственника»
2152  
2153  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4   Страница 65 из 67
2154  языка Gambas). Дело в том, что компиляторы BASIC/Gambas являются интерпретаторами.
2155  Они попросту выполняют исходный код строка-за-строкой, пока не достигнут конца главной
2156  процедуры (Main). Компиляция в данном случае на диск вообще ничего не пишет, а всего
2157  лишь удостоверяет тот факт (в случае успешного окончания процесса компиляции, конечно)
2158  что интерпретатору ясна каждая строка во всех файлах исходного кода входящих в наш
2159  проект. И он готов после запуска все их последовательно исполнить. Действие же «собрать
2160  исполнимый модуль» сначала проводит компиляцию (как мы выяснили это эквивалентно
2161  простой проверки синтаксиса) а затем этот проверенный исходный текст всех файлов проекта
2162  сплавляет в один выходной исполнимый модуль. Среда предлагает образовывать имя этого
2163  модуля по шаблону <имя_проекта>.gambas однако оно может быть любым и у нас будет
2164  возможность это имя указать. Однако, и это требуется понимать очень хорошо, между
2165  исполнимыми модулями произведенными средами KDevelop/Lazarus и обсуждаемым есть
2166  огромная, принципиальная разница:
2167                  ·   исполнимые       модули,      полученные        после    компиляции    в   средах
2168          KDevelop/Lazarus являются файлами содержащими «чистый» машинный код. ОС
2169          Linux остается просто «скармливать» байт за байтом содержимое таких модулей
2170          центральному процессору компьютера. Для исполнения тех же модулей на другом
2171          компьютере, не том где они были скомпилированы, требуется просто идентичная (или
2172          совместимая) ОС Linux
2173                  ·   исполнимые модули, полученные после процесса, названным нами
2174          «собрать исполнимый модуль»,в среде Gambas, машинного кода не содержат вообще.
2175          Они по-прежнему содержат исходный код на языке Gambas. Просто этот код
2176          агрегирован из всех файлов проекта и слегка упакован для экономии места. Так же это
2177          удобно для переноса готового приложения на другой компьютер (перенос одного
2178          пусть и большого файла много проще и гораздо лучше управляем, чем перенос
2179          пятисот мелких файлов). Тем не менее, принципиально это картину не меняет, код
2180          содержащийся в этом итоговом пакете «не понятен» центральному процессору. А
2181          понятен он лишь все тому же интерпретатору языка Gambas. Поэтому выход только
2182          один - запустить интерпретатор и указать ему данный пакет в виде входного файла.
2183          Тогда код на языке Gambas будет «на лету» преобразован интерпретатором в код
2184          машинный и, наконец-то, исполнен.
2185  
2186  
2187  
2188  Академия АйТи          Установка и администрирование ПСПО. Лекции. Часть 4         Страница 66 из 67
2189         В сухом остатке мы имеем следующий факт: исполнимый модуль произведенный
2190  средой Gambas не будет запускаться на другом компьютере даже имеющего идентичную ОС
2191  Linux. Для успешного запуска такого модуля (пакета) целевому компьютеру (помимо
2192  идентичной/совместимой операционной системы) требуется специальное приложение -
2193  интерпретатор языка Gambas. Однако полноценная среда разработки Gambas для запуска
2194  готового пакета не требуется, хотя, конечно, и не помешает такому запуску.
2195         Т.о. собрав выходной пакет с именем, скажем MyProj.gambas мы можем передать его
2196  на другой компьютер, предварительно удостоверившись в наличии интерпретатора языка
2197  Gambas на последнем. Приложение-интерпретатор представляет собой утилиту командной
2198  строки gbx2. Однако интерпретатор, как и положено классическому интерпретатору, умеет
2199  воспринимать строки на не упакованном языке Gambas, так как мы их набираем в редакторе.
2200  Поэтому gbx2 можно использовать для запуска из консоли файлов исходного кода с
2201  расширениями .module и .class. Это, кстати, еще один вариант распространения нашей
2202  программы - просто передать файлы исходного кода. Для их запуска, как легко видеть, среда
2203  разработки не нужна, нужна лишь утилита интерпретатора, gbx2. В .gambas-пакете же строки
2204  упакованы, поэтому требуется специальная разновидность интерпретатора - так же
2205  приложение командной строки gbr2. Так вот убедившись в наличии на целевом компьютере
2206  этой утилиты и набрав в его консоли команду gbr2 MyProj.gambas мы, наконец-то, запустим
2207  нашу готовую Gambas-программу на исполнение.
2208         Традиционно завершим разговор о языке Gambas и одноименной среде разработки
2209  предложением нескольких ссылок на ресурсы посвященным этим двум областям
2210  компьютерной науки:
2211         Официальный сайт проекта Gambas
2212         http://gambasrad.org
2213         Краткий учебник по языку Gambas
2214         http://en.wikibooks.org/wiki/Gambas
2215         Официальная документация по языку Gambas
2216         http://gambasdoc.org/help?en
2217  
2218  
2219  
2220  
2221  Академия АйТи           Установка и администрирование ПСПО. Лекции. Часть 4   Страница 67 из 67
2222  
2223  

ALTLinuxEdu: FrBrGeorge/DraftsAndJunk/PspoItRu/APSPO Programm-лекции ч4 (last edited 2009-11-02 10:13:41 by VladCherny)