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)
1887 …
1888 …
1889 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)
