WWW.KNIGA.LIB-I.RU
БЕСПЛАТНАЯ  ИНТЕРНЕТ  БИБЛИОТЕКА - Онлайн материалы
 

Pages:   || 2 | 3 | 4 | 5 |   ...   | 12 |

«1 Валерий Рубанцев Большой самоучитель Delphi XE3 Эта книга – условно-бесплатная, Ознакомившись с её содержанием, Вы должны либо стереть книгу, либо оплатить её стоимость. ...»

-- [ Страница 1 ] --

1

Валерий Рубанцев

Большой самоучитель

Delphi XE3

Эта книга – условно-бесплатная, Ознакомившись с её содержанием, Вы должны

либо стереть книгу, либо оплатить её стоимость.

Стоимость книги и формы оплаты Вы найдёте на сайте:

www.rvGames.de/buy.htm

Все права защищены. Никакая часть этой книги не может быть воспроизведена

в любой форме без письменного разрешения правообладателей.

Автор книги не несёт ответственности за возможный вред от использования информации, составляющей содержание книги и приложений.

Copyright 2012-2013 Валерий Рубанцев Лилия Рубанцева BEGIN Эта книга адресована тем читателям, которые имеют небольшой опыт программирования. В первую очередь – школьникам и студентам, умеющим обращаться с компьютером. Содержание книги не требует знания каких-либо других языков программирования, а внимательное отношение к многочисленным примерам поможет читателю быстро освоить самые необходимые типы данных, операторы, функции и другие элементы языка программирования Delphi.

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



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

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

Все описания сопровождаются многочисленными примерами - как этюдами, так и полноценными игровыми программами:

Тест космонавта, Mind Game, Tetris, Флип-Флоп, XorGame, Logos, Японский кросворд, Цветные линии, Жизнь и другими.

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

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

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





Валерий Рубанцев

Обозначения, принятые в книге:

–  –  –

Официальный сайт книги: www.rvGames.de Здесь вы можете скачать и другие книги автора.

Оглавление Большой самоучитель Delphi XE3

BEGIN

Оглавление

Delphi forever

Часть I. Уроки Delphi

Урок 1. Паскальная история

Turbo Pascal

Object Pascal

Delphi

Бесплатные версии Object Pascal

Семинар 1. Экскурсия по Delphi, или ОКОНчательный диагноз

Главное окно

Окно Менеджера проекта (Project Manager)

Окно Структуры проекта (Structure)

Рабочее окно

Страница приветствия (Стартовая страница, Welcome Page)

Окно Конструктора формы

Окно Редактора кода (Code Editor)

Окно Инспектора объектов (Object Inspector)

Окно/Палитра компонентов (Tool Palette)

Урок 2. Грамматика Delphi

Числа

Выражения

Идентификаторы

Комментарии

Программы и алгоритмы

Семинар 2. С чего начать?, или Проект, откройся!

Как сохранить файлы проекта на диске

Как загрузить проект с диска

Как закрыть проект

Урок 3. Переменные и константы

Константы

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

Переменные

Глобальные и локальные переменные и константы

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

Как работать с компонентами

Семинар 3. «Здравствуй, мир!», или Первое приложение… усилий

Самостоятельная работа

Урок 4. Процедуры и функции, или Разделяй и властвуй

Объявление процедуры

Объявление функции

Описание процедуры

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

Вызов процедур и функций

Локальные и глобальные подпрограммы

Формальные и фактические параметры

Общие приёмы работы с окнами/панелями

Семинар 4. Контрольное взвешивание, или Веское приложение

Последний штрих

Урок 5. Рекурсия, или Сказочка про белого бычка

Как не заблудиться в коде, или Секреты навигации

Семинар 5. Всё познаётся в сравнении, или Вычисляем НОК и НОД

Наибольший общий делитель

Наименьшее общее кратное

Урок 6. Простые типы данных

Целые типы

Вещественные типы (Действительные типы)

Перечисляемый тип

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

Интервальный тип (тип-диапазон, ограниченный тип)

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

Функции и процедуры для порядковых типов данных

Как добавить новый модуль или новую форму к проекту?

Семинар 6. Форма-заставка

Искусственное дыхание, или Оживляем форму-заставку

Бледная личность, или Уходящая натура

Урок 7. Операции и выражения

Операции

Выражения

Семинар 7. Одно- и многооконные приложения, или Сколько кожи на человеке.

155 Однодокументный интерфейс

Самостоятельная работа

Многодокументный интерфейс

ЧВС «Фенечки, или "Остероиды"

Урок 8. Циклюем циклы

Оператор FOR

Оператор WHILE

Оператор REPEAT

Вложенные циклы

Досрочный выход из цикла

Выводы

Семинар 8. Циклотрон, или Истории Древнего мира

Римские числа

Египетские пирамиды

Урок 9. Массивы, или Как разложить всё по полочкам

Одномерные массивы символов

Типы индексов

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

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

Семинар 9. Латинские квадраты, или Квадратно-гнездовой посев чисел.

............ 213 Самостоятельная работа

Урок 10. Строки, или Жестокие игры со словами

Короткие строки

Длинные ANSI-строки

Длинные строки Юникода

Другие типы строк

Мешанина из строк разных типов

Простые операции со строками

Семинар 10. Игра Виселица, или Hangman

Происхождение игры

Правила игры

Варианты игры

Пример игры

Стратегии игры

Программа, помогающая играть в Виселицу, - HangmanHelper

Самостоятельная работа

Дополнительный материал

Урок 11. Текстовые файлы, или FILEгранная работа со строками

Пифагоровы штаны

Функции для работы с файлами

Компоненты для работы с файлами

Семинар 11. Фракционирование, или Слова мелкого и крупного помола............. 268 Урок 12. Процедуры и функции для работы со строками

Семинар 12. Палиндромы, или Арабский взгляд на русские слова

Палиндромная программа

Самостоятельная работа

Урок 13. Множества

Операции над множествами

Операторы отношения

Сколько элементов в множестве?

Приоритет выполнения операций

Диаграммы Венна

Семинар 13. Разнобуквица, или SETка для слов

Супернаборщик

Самостоятельная работа

Наборщик

Самостоятельная работа

Анаграммы

Самостоятельная работа

Урок 14. Условный оператор IF

Семинар 14. Игра Угадай число, или Бинарный поиск

Правила игры

Стратегия игры

Программа для игры в 100

Урок 15. Оператор выбора CASE, или Выбирай, но осторожно.

Но выбирай!..... 316 Семинар 15. Лототрон, или Как помочь старушкам

Самостоятельная работа

Урок 16. Записи, или Рекорды в программировании

Оператор над записями With

Семинар 16. 21, или Игра в карты по-научному

Ближе к коду!

Подведём итоги

Самостоятельная работа

Урок 17. Трёхголовое ООП, или КЛАССный руководитель

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

Поля, свойства и методы

Конструктор и деструктор

Принципы ООП

Области видимости и «доступность» членов класса

Выводы

Семинар 17. Игра в КЛАССики, или Опять бОЧКОвое ЛОТО

Самостоятельная работа

ООПять лото!

Часть II. Практикум

Занятие 1. Неформальные формы

Шейпинг-класс, или Форменное безобразие

Колоритная фигура, или Долой серость!

Проба пера, или Mind Game - гимнастика для ума

Занятие 2. Тетрис, или Великолепная семёрка

Новый Пигмалион, или Картинная форма

Умелые руки, или Кнопки – своими руками

Тетрис a la Delphi

Хитрая механика, или Алгоритм – душа программы

Родословная тетриса

Художественные п(р)омыслы

Занятие 3. Викторина, или Все флаги в гости будут к нам

Занятие 4. Тест космонавта, или Форма как ракетоноситель

Стресс как порча жизни

Занятие 5. ДОСКОнально о сетке, или Занимательное полеводство

Поле в клеточку, или Компонент TDrawGrid

Игры-оборотни

XorGame, или Как обнулить матрицу

Другие игры-оборотни

Чёт и нечет

Ножки вверх!, или Головоломка с бокалами

Занятие 6. Живописная основа, или класс TCanvas

Геометрические фантазии, или Методы TCanvas

Заливная рыба, или метод FloodFill

Чините перья, или класс TPen

Наше вам с кисточкой, или класс TBrush

Траектории мысли, или Paths

Картинки с выставки, или Художественные методы канвы

Великий комбинатор, или Свойство CopyMode

Наш аниматограф

Движущиеся линии, или «Классная» программа

AVIация, или Клепаем клипы

Занятие 7. Компот из компонентов, или «А мне всегда чего-то не хватает…».

.... 796 Просто кнопка, или Как пройти в библиотеку?

Копай с умом!, или Пятнадцать человек на сундук мертвеца

Часть III. Факультатив

Факультатив 1. Фейсом к интерфейсу, или Дельфи, открой личико!

Горячие клавиши ИСР

Факультатив 2. Практические занятия, или Анатомия приложения

Файл проекта

Файлы формы

Файлы модулей

Файлы ресурсов

Параметры проекта

Как нам обустроить Delphi

Факультатив 3. Формы и окна

Элементы стандартного окна

Свойства формы

События формы

Методы формы

Факультатив 4. Японский кроссворд, или Восхождение на Фудзияму мысли........ 941 Просветление, или Что придумали японцы

Правила хорошего моветона

Решительный момент, или Берём быка за бока

Кибернетическое убийство времени, или Компьютер-поводырь

Решительный штурм, или Как расколоть японские кроссворды

Занимательная механика, или За кулисами формы

Каждому сверчку по шестку, или Нумеруем клетки

Мотаем на ус, или Наш задачник

Делайте с нами, или Тонкие штучки на компьютере

Компьютерная педагогика, или Пускай работает Иван

Мандрагора, или Зри в корень!

Магическая кнопка, или Первые аплодисменты

Мастерская Самоделкина, или Наши весёлые картинки

«Шлите апельсины бочками», или «Ждите ответа!»

«А напоследок я скажу…»

Генеалогическое древо, или Японская родня

Факультатив 5. Игра-головоломка Logos

Правила игры

Программируем от достигнутого

Всплывающее меню

«Отзывчивые» кнопки

Веб спешит на помощь

Управляющие кнопки

Всплывающее меню

Шиворот-навыворот и задом наперёд

Учимся лениться

«С любимыми не расставайтесь…»

Факультатив 6. Цветные линии, или Критическая масса мыслей

Мир Цветных линий

Нить Ариадны, или Как выбраться из лабиринта

Большая стройка, или «Линейное» программирование

«Требую продолжения банкета!», или Где начало того конца, которым оканчивается начало?

Факультатив 7. «Что наша «Жизнь»? – Игра!», или Клеточный автомат Джона Конвея

Законы Жизни

Как построить вселенную, или Даём жизни!

Факультатив 8. Бонусы, или Хитрая головоломка – хитори

Факультатив 9. FireMonkey, или Стильный интерфейс

Приложения FireMonkey

Компоненты FireMonkey

Привет, FireMonkey!

Happy END., или Карлсоны всегда возвращаются

Литература

–  –  –

Все примеры и программы для этой книги написаны в Turbo Delphi 2006 и в Delphi XE3. Это значит, что они без всяких изменений могут быть загружены в любую версию Delphi, начиная с Turbo Delphi 2006 и заканчивая самой последней - Delphi XE3. Если же вы хотите использовать только код, а не готовые файлы приложения, то большинство программ будет прекрасно работать во всех версиях, начиная с четвёртой (код придётся копировать вручную). Более того, вы можете бесплатно скачать программу Lazarus и самостоятельно создавать интерфейс и набирать код. Это долго, но гораздо более полезно, чем питаться «консервами». Таким образом, проблем со средой разработки программ и в принципе быть не может. Что касается самого языка программирования Delphi, то ничего мощнее и удобнее вы не найдёте. С его помощью вы можете писать любые программы – как для себя, так и для семьи, школы и даже коммерческие трёхмерные игры на основе DirectX 9. Здесь результат больше зависит от программиста, чем от языка программирования, поскольку все современные языки заведомо мощнее, чем вам может потребоваться.

Если вы хотите получить от программирования не только пользу, но и удовольствие, выбирайте Delphi. Здесь вполне уместно вставить рекламный довод: «При всём богатстве выбора другой альтернативы нет». Из всех современных универсальных языков программирования высокого уровня он наиболее «гуманный», а потому наименее машинный. Тут с ним не могут сравниться ни C/C++, ни C#, ни бейсик, ни другие, более экзотические языки. Поэтому программист может полностью сосредоточиться на логике алгоритма, а не на его подгонке к особенностям процессора или причудливым конструкциям самого языка программирования. Кроме относительной простоты, у Delphi есть и другие достоинства. Он универсальный, то есть позволяет решать практически любые задачи: от квадратных уравнений до создания современных трёхмерных игр. Скомпилированные программы очень небольшие по размеру и очень быстрые, при этом они не требуют для своей работы установки дополнительных программ и библиотек. Delphi помогает очень быстро и удобно разрабатывать приложения с очень красивым графическим интерфейсом.

Часть I. Уроки Delphi

–  –  –

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

На уроках вы будете изучать язык программирования Delphi и приёмы работы в среде программирования Delphi XE3. Здесь вы напишете короткие программы-примеры, на которых легче усвоить пройденный материал.

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

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

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

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

–  –  –

Первый паскаль (тогда ещё Паскаль) появился в 1970 году. Его автор – профессор Швейцарского института информатики Никлаус Вирт – назвал его в честь великого французского учёного 17-го века Блеза Паскаля, который, кроме прочего, изобрёл автоматическое устройство для суммирования чисел.

Никлаус Вирт «причастен» к созданию и других языков программирования – Эйлер, Модула, Модула-2, Оберон.

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

К другим достоинствам паскаля можно отнести:

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

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

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

Надёжность программ, хотя это и заставляет программиста писать немало «лишнего» кода. Например, все переменные, константы и другие объекты программы должны быть описаны в соответствующих разделах модуля или подпрограммы, хотя в языке С объявлять новые переменные разрешается даже внутри операторов. Нет в паскале и «хитроумных» конструкций, которыми изобилует язык С.

Здесь не приветствуются «трюки», в программе на паскале код должен быть понятен и недвусмыслен.

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

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

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

Итак, Никлаус Вирт наделил свой язык программирования только самыми необходимыми возможностями, но программистов много и они решают разные задачи, поэтому стали появляться расширения языка паскаль, которые затрудняли переносимость программ с одного компьютера на другой. Поэтому в 1982 году был «законодательно» установлен стандарт языка паскаль ISO7180.

–  –  –

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

В 1983 году на рынке появился Turbo Pascal 1.0 американской фирмы Borland International для CP/M и компьютеров 8086.

В 1985 году вышла новая версия - Turbo Pascal 3.0. Он был совмещён с быстрым компилятором и редактором кода, что обеспечивало пользователя всем необходимым для быстрой разработки программ под операционную среду MS-DOS. Именно эти качества и позволили паскалю «проникнуть» в школы и институты, где его изучали как первый язык программирования.

С выходом версии Turbo Pascal 5.5 пакет «обзавёлся» встроенным отладчиком, который ещё больше ускорил разработку программ и привлёк на свою сторону немало профессиональных программистов. Был «дополнен»

и язык паскаль (настолько, что Turbo Pascal считается не расширением, а другим языком программирования, основанной на паскале), например, он умел работать с графикой и большими программами, разбитыми на модули, впервые появилась поддержка объектно-ориентированного программирования (ООП), к которому сам Вирт относился с большой долей иронии.

В 1992 году была выпущена последняя версия пакета - Turbo Pascal 7.0, которая до сих пор используется в школах для обучения программированию. Он имеет многооконный редактор, обширную систему помощи, текстовый редактор с выделением элементов языка разным цветом, позволяет включать в код вставки на ассемблере, что делает программу очень быстрой. В этой версии были полностью реализованы возможности ООП, появился типизированный адресный оператор @, открытые массивы и строки. Всё вместе это позволило программистам эффективно решать новые задачи.

Turbo Pascal 7.0 был предназначен для любительского программирования под MS-DOS, а вышедшая одновременно с ней версия Borland Pascal 7.0 – для профессионалов, она позволяла писать программы для работы в ОС Window 3.1.

Object Pascal Седьмая версия оказалась последней для языка Turbo Pascal. После него фирма Borland начала выпускать интегрированную среду быстрой разработки программ Delphi, основой которой стало объектноориентированное расширение языка Turbo Pascal, получившее название Object Pascal.

Первая версия Delphi позволяла разрабатывать программы под старую 16разрядную платформу Windows. Начиная со второй версии, программы компилируются под 32-разрядную ОС Windows.

Object Pascal в сравнении с языком Turbo Pascal получил новые возможности:

Появились интерфейсы, которые напоминают классы, они были введены для поддержки COM технологии фирмы Microsoft.

Добавлена перегрузка процедур и функций с помощью ключевого слова overload, перегрузка операторов, динамические массивы, ключевое слово object было заменено словом class, чтобы устранить двусмысленность между описанием объекта и самим объектом. В Turbo Pascal были объекты, но не было классов, описывающих эти объекты.

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

<

–  –  –

Начиная с седьмой версии, фирма Borland стала называть язык программирования Object Pascal точно так же, как и саму ИСР – Delphi. Кстати говоря, именно седьмая версия очень популярна у программистов и сейчас следующие всё дальше и дальше уходят от полюбившегося всем паскаля.

ИСР, а затем и язык программирования Delphi были названы в честь древнегреческого города Дельфы, где находился храм Аполлона и дельфийский оракул (вот он-то и повлиял на выбор названия). Этот храм украшал заставку к четвёртой версии Delphi (Рис. У1.1).

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

Рис. У1.1. Храм Аполлона на заставке Delphi 4 Следующие версии Delphi обозначались годом выхода (в коммерческих целях – не текущим, а следующим) и могли создавать приложения как для Windows, так и для платформы.NET: Borland Delphi 2005 (по счёту это 9-я версия), Borland Delphi 2006 (10-я версия, компания CodeGear), наряду с ней была также выпущена «облегченная» версия - Turbo Delphi 2006. Затем последовали Delphi 2009 и Delphi 2010 (Embarcadero RAD Studio 2010), после чего компания Embarcadero запустила новую линейку Delphi – XE.

Delphi XE, или Delphi 2011 была выпущена в 2010 году, Delphi XE2 - в 2011 и последняя на сегодняшний день версия Delphi XE3 - в 2012. Она поддерживает 64-битную ОС Windows, а также ОС Mac OS и iOS, так что теперь на Delphi можно разрабатывать многоплатформенные приложения.

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

Поскольку Delphi - наследник славного паскаля, исходный код программ, написанных на нём, очень лёгок для понимания, в чём вы скоро сами сможете убедиться!

Бесплатные версии Object Pascal Все коммерческие версии Delphi, понятное дело, стоят недёшево и вряд ли доступны начинающим программистам, однако не перевелись ещё робингуды: вы можете свободно скачать и пользоваться компиляторами языка Object Pascal, например, Free Pascal (Free Pascal Compiler), TopSpeed Pascal (версия языка Turbo Pascal), TMT Pascal, Virtual Pascal и GNU Pascal. В первую очередь можно рекомендовать Lazarus – аналог среды разработки программ Delphi, который в качестве компилятора использует Free Pascal (Рис. У1.2).

Рис. У1.2. Lazarus поздравляет вас с праздником!

С его помощью вы сможете писать программы не только для Windows, но и для других операционных систем - GNU/Linux, Mac OS X, FreeBSD, WinCE.

–  –  –

На первом семинаре мы бегло рассмотрим основные элементы интерфейса Delphi XE3. Более подробно вы познакомитесь с ними на Факультативе 1.

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

Сразу после загрузки Delphi XE3 вы увидите такую картину:

Рис. С1.1. Общий вид ИСР Delphi XE3 Над всеми другими окнами «возвышается» Главное окно. На нём размещаются Главное меню программы и Панели инструментов с кнопками быстрого доступа.

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

–  –  –

Главное меню (Main Menu) Находится сразу под заголовком Главного окна и содержит несколько подменю с множеством команд.

File

- загрузка и сохранение файлов.

–  –  –

Edit

– редактирование кода и компонентов на форме.

Search

– поиск и замена последовательности символов (текста) в исходном коде.

View

– работа с окнами и панелями ИСР.

Project

– работа с файлами проекта.

Run

– запуск и отладка программы в среде Delphi:

Help

– вызов справки помощи.

Обратите внимание на то, что самые «популярные» команды Главного меню имеют клавиатурные сокращения. Например, отправить в буфер обмена выделенный фрагмент кода (или компонент) можно, нажав одновременно клавиши Ctrl и C, а вставить в позицию курсора (или на форму, если речь идёт о компоненте) - клавишами Ctrl и V. Безусловно, это гораздо удобнее, чем каждый раз бродить по просторам меню. Другая возможность повышения комфортности работы в ИСР – использовать кнопки на Панелях инструментов.

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

Standard – стандартная:

- команда New Items очень часто применяется для присоединения новой формы или модуля к проекту.

- аналог команды File Reopen. Позволяет быстро открывать сохранённые на диске проекты. Нажмите стрелочку справа от папки, чтобы раскрыть список последних проектов и файлов.

- аналог команды File Save (быстрые клавиши - Ctrl+S).

- аналог команды File Save all (быстрые клавиши – Shift + Ctrl+S).

- аналог команды File Open Project (Ctrl+F11). Быстрое открытие сохранённого на диске проекта.

View - просмотр:

- аналог команды View Unit (Ctrl+F12). Выводит на экран список всех модулей приложения, в котором можно выбрать нужный для отображения в окне Редактора кода.

- аналог команды View Form (Shift+F12). Выводит на экран список всех форм приложения. Выбранная форма появляется в окне Конструктора формы.

- аналог команды View Toggle Form/Unit (F12). Переключается между окном Редактора кода и окном Конструктора формы (если в проекте несколько форм, то сначала выберите нужную предыдущей командой).

Debug – отладка:

- аналог команды Run Run (F9). Используется очень часто для запуска текущего проекта.

- аналог команды Run Run Without Debugging (Shift+Ctrl+F9).

Запуск текущего проекта без отладки.

Окно Менеджера проекта (Project Manager) Расположено в правом верхнем углу ИСР и показывает все файлы текущего проекта.

Менеджер проекта облегчает работу с файлами проекта. Например, после нажатия правой кнопки мыши на строчке Unit1.pas (главный модуль проекта), на экране появится контекстное меню.

В нём вы можете сохранить файл модуля на диске (команды Save или Save As…), переименовать его (Rename) и удалить из проекта (Remove From Project). Команда Открыть (Open) действует аналогично клавише F12, то есть открывает окно Конструктора формы (если курсор находится в строке Unit1.dfm) или окно Редактора кода (если в строке Unit1.pas).

Окно Структуры проекта (Structure) Находится слева вверху. Оно отображает иерархическую структуру компонентов на форме (когда открыто окно Конструктора формы) или структуру кода программы (когда открыто окно Редактора кода).

Рабочее окно Рабочее окно представляет собой панель с вкладками.

Первоначально вкладка только одна – Welcome Page, но после открытия нового проекта или после загрузки существующего количество вкладок увеличивается:

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

В режимах конструирования формы и редактирования кода под Рабочим окном, в строке состояния также появляются три вкладки:

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

нажмите горячую клавишу F12;

–  –  –

.

Страница приветствия (Стартовая страница, Welcome Page) При первом запуске Delphi XE3 в Рабочее окно загружается страница Welcome Page (Рис. С1.2). В её верхней части находится список последних проектов, над которыми вы работали - Recent Projects. Он позволяет очень удобно и быстро возвращаться к работе над приложениями.

Ниже вы найдёте кнопки New Project… и Open Project…, с помощью которых можно начать новый проект или открыть существующий, если он отсутствует в списке Recent Projects.

В правой части Страницы приветствия располагается Список часто открываемых проектов (Recently Opened Projects).

По сути, Стартовая страница представляет собой браузер, подобный Internet Explorer, поэтому непосредственно из неё вы можете перейти к чтению новостей на сайте фирмы Embarcadero или открыть любую другую страницу (если ваш компьютер имеет доступ к Интернету). Вот, например, как выглядит статья о языке Delphi на сайте Wikipedia, загруженная в Рабочее окно ИСР (Рис. С1.3).

Рис. С1.2. Стартовая страница Рис. С1.3. Читаем в Delphi o Delphi!

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

Окно Редактора кода (Code Editor) В окне Редактора кода вы можете создавать и редактировать код программы (Рис. С1.4).

Рис. С1.4. Окно Редактора кода Редактор кода представляет собой обычный текстовый редактор. Сначала в нём открыта для редактирования только одна страница – с исходным текстом (заготовкой) модуля формы Form1 разрабатываемого приложения. Его название Unit1.pas находится в заголовке окна и на вкладке Рабочего окна.

В редактор можно загрузить и другие текстовые файлы, например, файл проекта или других модулей проекта (выбрать нужный можно, выполнив

–  –  –

Окно Инспектора объектов (Object Inspector) Окно Инспектора объектов находится под панелью Структуры проекта и имеет две страницы (вкладки) - Properties и Events. Каждая из них разделена на две части вертикальной линией, которую можно передвигать мышкой. Чтобы открыть нужную страницу, щёлкните, как обычно, на её ярлычке.

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

На странице Events вы найдёте все события, на которые реагирует текущий компонент.

Окно/Палитра компонентов (Tool Palette) Панель инструментов (Tool Palette) находится в правом нижнем углу ИСР, под окном Менеджера проектов.

В Delphi XE3 называется Палитрой инструментов, но мы будем также использовать и её прежнее название – Палитра компонентов, - которое более точно определяет её назначение.

Сразу после загрузки ИСР вы увидите в ней список проектов, которые можно создавать в Delphi (Рис. С1.5, слева). Щёлкните на строчке Delphi Projects, чтобы развернуть список доступных приложений (Рис. С1.5, справа).

Чтобы открыть список компонентов, щёлкните по строке VCL Forms Application. В Панели инструментов появится список компонентов (Рис. С1.6), а также одновременно откроется новый проект.

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

Рис. С1.5. Палитра инструментов после запуска Delphi Чтобы выбрать нужную страницу компонентов, щёлкните по значку с плюсиком или просто на заголовке страницы, при этом страница раскрывается, показывая список (значки и названия) всех своих компонентов (Рис. С1.7).

Повторный щелчок сворачивает страницу – очень удобно!

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

Так как страниц с компонентами очень много, иногда бывает удобнее найти нужную и быстро перейти к ней с помощью списка, который раскрывается при нажатии на значок Show palette categories (Рис. С1.8).

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

Рис. С1.6. Полный список компонентов Рис. С1.7. Открытая страница Standard Рис. С1.8. Список Рис. С1.9. Ищем нужный компонент компонентов по категориям Так как компонентов огромное множество, то очень нелегко найти нужный компонент. Но если вам известно его название, то напечатайте его в окне поиска (Рис. С1.9), и в Палитре компонентов вы получите весь список подходящих компонентов (он автоматически обновляется по мере ввода новых букв). Щёлкните по названию компонента, и он появится на форме.

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

–  –  –

фрейм.

главное меню программы.

контекстное меню, появляющееся на экране при щелчке правой кнопкой мыши.

метка; используется для вывода надписей на форму.

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

простой многострочный текстовый редактор.

стандартная кнопка.

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

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

список строк.

комбинированный список (текстовое поле и список).

полоса прокрутки, скроллер.

контейнер для флажков.

контейнер для переключателей.

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

невизуальный компонент, создаёт список событий.

–  –  –

аналог компонента Edit, но позволяет организовать ввод данных по образцу (телефонный номер, дата…).

сетка для вывода строк в виде таблицы.

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

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

простейшие геометрические фигуры (примитивы): эллипсы и прямоугольники.

рамка.

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

список с флажками.

разделитель между двумя компонентами; позволяет изменять их размеры во время выполнения программы (примером может служить разделительная «черта» в Инспекторе объектов).

аналог компонента Label.

плавающая панель инструментов.

группа кнопок категорий.

компонент, похожий на предыдущий, но не поддерживает категории.

–  –  –

Win 3.1

– компоненты для создания интерфейса в стиле Win 3.1 (Рис. С1.13). Их основное назначение – сохранить совместимость с программами, написанными на ранних версиях Delphi. Многие из этих компонентов имеют 32разрядные аналоги, которые и следует использовать при написании приложений.

Рис. С1.13. Палитра Win 3.1

–  –  –

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

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

Палитра компонентов имеет своё контекстное меню, которое появляется, как обычно, при нажатии правой кнопки мыши в области палитры и помогает настроить Палитру компонентов (Рис. С1.16).

Рис. С1.16. Контекстное меню Палитры компонентов Команда Add New Category… позволяет добавить новую страницу в конец Палитры компонентов. Сначала она будет пустая, но вы можете перетащить на неё компоненты с тех страниц, на которых вам обычно бывают нужны только некоторые компоненты.

Команда Delete…, наоборот, удаляет выбранную страницу вместе с её компонентами.

Команда Rename… позволяет переименовать выбранную страницу.

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

Команды Collapse All и Expand All сворачивают и раскрывают все страницы палитры, соответственно.

Установленный флажок Lock Ordering запрещает изменять порядок страниц в палитре.

Команда Reset Palette… удаляет все пользовательские настройки палитры. Все страницы Палитры компонентов появятся в первозданном виде, то есть точно такими, какими они были при первом запуске программы.

Естественно, все ваши труды по благоустройству палитры пойдут насмарку.

Команда Properties открывает диалоговое окно Options, в котором можно настроить по своему вкусу внешний вид Палитры компонентов: размер значков компонентов (Button Size), окраску элементов палитры (Color Schemes), формат надписей на ней.

Установленный флажок Stay on Top всегда располагает Панель компонентов поверх других окон ИСР.

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

–  –  –

Программа на языке Delphi в окне Редактора кода напоминает обычный текст, состоящий из слов, чисел и различных знаков. И это естественно, ведь программист набирает его на своей клавиатуре и не может напечатать никакой «загогулины» и «отсебятины».

Зато почти все символы на клавишах используются в программах:

Все строчные и прописные буквы как латинского, так и русского алфавита, а также знак подчёркивания _ и пробел.

–  –  –

Специальные символы # $ & ' ( ) * +, -. / : ; = @ [ ] ^ { }. Некоторые пары этих символов: (* (. *).).. // := = = имеют собственное значение. Например, круглые скобки с точкой заменяют квадратные скобки, а со звёздочкой – фигурные. Такая замена может потребоваться, если на клавиатуре отсутствуют эти символы.

Известно, что обезьяна, нажимая на клавиши печатной машинки (а теперь и компьютера), может написать Войну и мир. Ценность такой возможности, конечно, невелика, потому что Лев Толстой успел это сделать раньше, но вероятность плагиата всё равно остаётся. Таким образом, наука допускает, что, взяв в руки палку, обезьяна стала человеком, а взяв клавиатуру, сможет стать писателем. Анализ текстов знаменитой детективной писательницы Дарьи Донцовой раскрыл секрет её творчества: на неё работает весь обезьяний питомник Московского зоопарка.

–  –  –

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

Примеры чисел в Delphi:

+27 865 5470 - положительные целые числа

-3 -87 -555 -9536 - отрицательные целые числа 2.476 72.0005 - положительные действительные числа 0.9

-0.7 -21.43 -573.9999 - отрицательные действительные числа Целые и действительные числа называют также числовыми константами (целыми и действительными, соответственно).

Целые числа иногда записывают и в 16-ричном виде с помощью цифр 0..9 и латинских букв A..F (или a..f).

Перед таким числом должен стоять символ $:

$0A $20 $FFFFFFFF

Действительные числа могут записываться и в научной нотации:

1.5e8 (1.5E8), что составляет 150 000 000 (догадайтесь, что за число!).

–  –  –

1+2 2*2 3 * 4 + 5 – 6/2

-+12

-2.67 * 3.14 + -3/2 – 7.01 Значение числовых (и других) константных выражений вычисляются транслятором при компиляции программы и подставляются вместо них, поэтому константные выражения не могут содержать переменных (ведь их значения могут изменяться!), а также вызовов функций (за редким исключением).

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

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

(2 + 4 - 1) / 5 * 11 (3.1415 – 1.0) / 7.78 * (45 - 7) Между числами и знаками операций может быть любое число пробелов, но можно печатать их и вплотную друг к другу (особенно это полезно делать, чтобы испортить зрение и откосить от армии).

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

–  –  –

Если мы хотим обратиться к человеку, то должны знать его имя (в особо ответственных случаях – полное ФИО). То же самое и в Delphi – редкий объект обходится без имени, которое также называется идентификатором.

Формально идентификатором может служить любая последовательность букв и цифр, начинающаяся с буквы или знака подчёркивания. Длина идентификатора не ограничена, но транслятор учитывает только первые 255 символов (трудно даже представить себе имя такой длины!). Таким образом, _ i abcd qwerty i_j g56 o8j90 это правильные имена для любых объектов программы. Но они годятся только в качестве кодов к замкам, потому что не имеют никакого смысла, доступного разумению.

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

–  –  –

Пространная цитата из Брюса Мак-Кинни, конечно, не случайна – она должна наставить нас на путь истинный при наречении новорожденного элемента программы.

Delphi даёт всем вновь созданным объектам маловразумительные имена:

Project1 Form1 Unit1 Если вы добавите на форму кнопку, то она будет называться, конечно, Button1 (Рис. У2.1). Сможете ли вы или какой-нибудь другой, более проницательный человек, догадаться, что будет, если нажать на эту кнопку? – Вряд ли, ведь и на самой кнопке тоже написано Button1!

Рис. У2.1. Кнопка, на которой написано, что это кнопка!

И не надейтесь, что со второй кнопкой будет лучше, Delphi назовёт её – «никогда не догадаетесь!», - как восклицала в подобных таинственных случаях Регина Дубовицкая, – Button2.

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

Этим не следует злоупотреблять, но это так.

Запрещено использовать не по прямому назначению только зарезервированные слова:

–  –  –

Не следует применять всуе и некоторые другие слова, например, директивы. Такие ограничения не должны вас огорчать: мало ли в русском языке других слов!

–  –  –

Плохие идентификаторы, как и плохие имена, затрудняют жизнь людей и программ. Чтобы облегчить выбор сотрудник фирмы Майкрософт Чарльз Силош предложил весьма сложную систему составления имён объектов программы. Как известно, венгерский язык очень сложный, но «венгерской» эту систему прозвали не поэтому, просто Чарльз Силош по происхождению венгр.

Существует немало разновидностей этой системы, но мы остановимся на самой простой и внятной из них.

Итак, «по-венгерски» любой идентификатор составляют из двух частей:

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

Например, префикс i обозначает целый тип.

Тогда координаты точки на экране можно хранить в двух переменных:

Var iX, iY: integer; или или iXCoord, iYCoord: integer;

iCoordX, iCoordY: integer;

Если имеется в виду не точка, а мяч, то идентификатор легко приспособить и к этому случаю:

Var iXBall, iYBall: integer;

Префикс может также отражать назначение объекта:

c (counter) – счётчик;

f (flag) - переменная логического типа;

p (pointer) – указатель;

n, num (number) – число, количество чего-либо;

cur (current) – текущее значение;

tmp (temporal) – временное значение.

Вы можете выработать свою систему наименования, но некоторые распространённые префиксы желательно при этом учитывать.

–  –  –

Этот список вы можете продолжить сами – место в таблице предусмотрительно оставлено!

Глобальные константы обычно записывают прописными буквами, разделяя отдельные слова знаком подчёркивания:

Const MAX_WIDTH= 20;

MAX_HEIGHT= 24;

Ну, вот, теперь вы можете «обзывать» объекты строго по-научному!

–  –  –

В защиту русских слов: их разрешено использовать не только в комментариях, но и - весьма опрометчиво! - для именования переменных и прочих элементов программы. Это значит, что вы можете написать не только fence:= 1, но и забор:= 1. И даже то, что потом пишут на заборе (я имею в виду надпись Осторожно - злая собака!). Обязательно так и делайте, и тогда ни на одном вражеском компьютере исходный текст вашей программы работать не станет, а постоянное переключение раскладки клавиатуры с английской на отечественную сильно укрепит ваше материалистическое мировоззрение и повысит меткость русского слова.

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

Например, комментарий i:= i+1; // увеличиваем значение переменной i на единицу ничего не объясняет, а просто пересказывает действие оператора сложения.

Комментарий с:= с+1; // увеличиваем значение счётчика слов уже значительно лучше, поскольку мы понимаем, что в этом месте кода подсчитывается количество слов, а не абстрактных объектов.

Когда вы только пишете программу, вам и без комментариев всё в ней понятно. Но если вам понадобится модифицировать программу, написанную несколько месяцев назад, вот тогда и начнутся проблемы: без комментариев придётся восстанавливать весь алгоритм заново, а это иногда бывает труднее, чем с начала придумать новый. Не меньше трудностей вы создадите и своим друзьям-товарищам, если поделитесь с ними своей программой. Вряд ли им доставит удовольствие многочасовой разбор «немого»

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

А вот транслятору ваши комментарии ни к чему, он просто игнорирует их при компиляции программы, так что от ваших пояснений выполняемый код не увеличится ни на один байт.

Обычно комментарии занимают целиком всю строку либо остаток строки:

// увеличиваем значение счётчика слов с:= с+1;

с:= с+1; // увеличиваем значение счётчика слов В этом случае они начинаются двумя слешами, за которыми и следует собственно комментарий. В самом комментарии разрешается использовать любые символы.

Реже комментарии располагают внутри кода (в любом его месте), тогда они обрамляется фигурными скобками:

с:= {увеличиваем значение счётчика слов} с+1;

Вместо фигурных скобок можно использовать круглые скобки со звёздочками:

с:= (* увеличиваем значение счётчика слов *) с+1;

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

{ // увеличиваем значение счётчика слов с:= с+1;

с:= с+1; // увеличиваем значение счётчика слов с:= {увеличиваем значение счётчика слов} с+1;

с:= (* увеличиваем значение счётчика слов *) с+1;

} Если вам при отладке программы понадобится закомментировать блок кода, то достаточно заключить его в фигурные скобки. С одностррчными комментариями всё будет нормально, но комментарии с фигурными скобками будут вызывать коллизии. Обратите внимание на третью строку кода: закрывающая фигурная скобка завершает комментарий, и весь следующий код оказывается раскомментированным, что приведёт к ошибке, как только компилятор наткнётся на вторую закрывающую фигурную скобку.

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

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

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

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

–  –  –

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

Чтобы начать новый проект, нажмите кнопку New Items и в открывшемся диалоговом окне выберите VCL Forms Application (Рис. С2.1).

Рис. С2.1. Начинаем новый проект кнопкой New Items!

Открыть новый проект можно также из Панели инструментов (Рис. С2.2).

Рис. С2.2. Начинаем новый проект из Панели инструментов!

Из окна Менеджера проекта (Рис. С2.3).

Рис. С2.3. Начинаем новый проект из Менеджера проекта!

Из Окна приветствия, нажав строчку New Project… (Рис. С2.4).

Рис. С2.4. Начинаем новый проект из Окна приветствия!

И из Главного меню, выполнив команду Project Add New Project… (Рис.

С2.5) Рис. С2.5. Начинаем новый проект из меню Project!

или File New VCL Forms Application – Delphi for Win32 (Рис. С2.6).

Рис. С2.6. Начинаем новый проект из меню File!

В Рабочем окне появится новая закладка – Unit1 и главная форма приложения (Рис. С2.7).

Рис. С2.7. С открытием!

И хотя вы ещё ничего не успели сделать, ваш проект уже содержит пустую форму Form1 (она находится в окне Конструктора формы), модуль формы Unit1.pas (в окне Редактора кода) и ещё несколько файлов..

–  –  –

Так как с этого и следует начинать работу над новым проектом, то создайте для него на диске отдельную папку. Затем нажмите кнопку - аналог команды File Save all (быстрые клавиши – Shift + Ctrl + S) на стандартной панели и в открывшемся диалоговом окне перейдите в эту папку.

–  –  –

Вместо названия модуля по умолчанию Unit1 выберите более подходящее, например MyUnit, и сохраните его на диске. Тут же проделайте эту операцию и файлом проекта (назовём его MyProject).

–  –  –

Менеджер проекта также облегчает работу с файлами проекта. Например, после нажатия правой кнопки мыши на строчке Unit1.pas, на экране появится контекстное меню (Рис. С2.8).

Рис. С2.8. Контекстное меню Менеджера проекта В нём вы можете сохранить файл модуля на диске (команды Save или Save As…), переименовать его (Rename) и удалить из проекта (Remove From Project).

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

Любой проект на Delphi включает в себя довольно много файлов.

Чтобы они не перемешались с другими файлами, их нужно сохранять в отдельной папке, желательно в корневом каталоге диска и под «прозрачным» названием, иначе потом вам придётся долго искать её среди прочих папок с ничего не значащими именами типа «абвгд» или «ёклмн». Можно предварить название папки символом подчёркивания «_», тогда она будет находиться в начале списка папок на диске. Закончив работу над проектом, вы можете стереть этот символ, папку заархивировать и убрать на вечное хранение в папку для всех ваших проектов на Delphi. Такой подход позволит вам всегда быстро находить необходимые файлы.

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

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

После того как вы сохранили файлы проекта под другими именами, они будут обновлены и в заголовках Главного окна и окна Редактора кода. А заголовок формы отражает значение её свойства Caption, которое можно установить в Инспекторе объектов. Обычно это название программы и номер её версии. Само же название формы задаётся свойством Name в том же Инспекторе объектов. Если значение свойства Caption не установлено, то именно название формы и появится в её заголовке (Рис. С2.9).

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

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

При большом риске зависания программы её лучше скомпилиро

–  –  –

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

Нажмите кнопку на Панели инструментов, и через некоторое время на экране появится форма, представляющая собой стандартное окно Windows (Рис. С2.10), которое можно передвигать, сворачивать, разворачивать, изменять его размеры и закрывать (в Панели задач Windows появится также название вашего проекта со значком из файла ресурсов проекта). Больше ничего вы от неё не добьётесь, поэтому выполните именно последнюю из доступных команд, чтобы вернуться в среду программирования Delphi.

Рис. С2.10. Окно приложения

Если вас терзает любопытство, загляните в папку с проектом – в ней появился файл MyProject.exe (а именно в папке Win32 Debug), который обычно и называют программой. И пусть вы не написали до сих пор ни одной строчки кода, но уже получили самую настоящую программу с выбранным вами названием. Вы можете запустить её из Проводника Windows или файлового менеджера, дважды щёлкнув по названию (или значку) мышкой. Конечно, ничего нового она не сделает по сравнению с первым стартом, но её можно скопировать на диск и запустить на любом другом компьютере – она не требует для своей работы никаких других файлов.

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

Исходный код программы находится в папке Пример.

–  –  –

Особенно удобна для этого кнопка Open на Панели инструментов.

Нажмите стрелочку справа от папки, чтобы раскрыть список последних проектов и файлов, и выберите нужный. Так же действует и команда Главного меню File. Если нажать на саму кнопку, то она выполнит команду Главного меню File.

Нажав строчку Open Project… на Странице приветствия (Рис. С2.11) или кнопку (Ctrl+F11) на Панели инструментов, Рис. С2.11. Открываем проект на Стартовой странице вы попадёте в диалоговое окно выбора папки проекта (Рис. С2.12).

Рис. С2.12. Папки с проектами на диске Команда Главного меню File также открывает это диалоговое окно.

Чтобы открыть проект, нужно загрузить один из файлов с расширением.dpr или.dproj, которые находятся в папке с проектом.

Как закрыть проект Рано или поздно, работу над проектом придётся закончить и заняться менее приятными делами.

Можно закрывать каждый файл по отдельности (сначала его нужно вывести в окно Редактора кода), нажимая строку в Главном меню File. Если в файле остались несохранённые изменения, то Delphi напомнит вам об этом (Рис. С2.13).

Рис. С2.13. Не торопитесь!

Разом закрывает все файлы проекта команда File. В этом случае вы можете получить другое предупреждение (Рис. С2.14).

Рис. С2.14. Сохраняйте изменения!

Естественно, если у вас на то нет веских причин, следует нажать кнопку Yes.

После этих действий вы попадёте на Страницу приветствия и сможете открыть любой проект.

Если же вы полностью и окончательно утолили жажду программирования, то закройте Delphi командой File или, как и всякое другое приложение, нажав крестик в правом верхнем углу Главного окна Delphi (Рис.

С2.15).

Рис. С2.15. Тут и Delphi конец!

–  –  –

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

Как мы уже знаем, все числа являются числовыми константами.

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

'Z' Cos(3.14) 'string1 ' Chr(255) Точно так же из любых символов мы можем составить символьные (один любой символ) и строковые константы (любое количество любых символов, в том числе и ни одного). Такие константы заключаются в одинарные (не двойные!) кавычки:

'R' '7' 'Ж' 'Э' – символьные константы 'G' '' – пустая строка, в которой нет ни одного символа 'G' 'Constant' 'Строковая константа' - строковые конDelphi' станты

Строковые и символьные константы можно соединять знаком +:

'Delphi' +'-' + ' это наш выбор! ' Значением этого выражения будет строка «Delphi - это наш выбор!»

'2 + 2' - тоже строковые константы! Их значениями являются именно строки, а не числа, поэтому значение выражение '2 + 2' вовсе не 4!

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

Кроме того, существуют логические константы True (соответствует значению истина), False (ложь), а также константа nil (0, используется как значение указателей).

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

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

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

Const Имя= значение;

Здесь значение – это константа или константное выражение.

Например:

const num= 123;

pi= 3.1415926;

pi2= pi * 2;

e12= 2.1728 / 2;

str= 'string1';

Flag= TRUE;

Ch= 's';

Именованные константы получают своё значение при объявлении и потом изменить его не могут.

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

Разделов объявления констант и переменных может быть сколько угодно:

const num= 123;

pi= 3.1415926;

var s: single;

c1: char;

const c: integer= $ffff;

Вы должны были обратить внимание на то, что тип констант разный, но нигде не указан. Тогда каким же образом компилятор определяет его? – По виду константы или константного выражения! Действительные числа должны быть записаны с десятичной точкой или в научной нотации. Все остальные числа считаются целыми (десятичными и 16-ричными). Символьные (один символ) и строковые (любое количество символов) константы должны быть заключены в одиночные кавычки. Логические должны иметь значение TRUE или FALSE.

При компиляции программы значения всех именованных констант вычисляются и подставляются в исполняемом коде вместо их идентификаторов.

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

Пусть нам нужно написать программу, играющую в шашки. Доска имеет 8 вертикалей и 8 горизонталей. Если эти числа использовать в исходном коде, то эти восьмёрки невозможно будет отличить от других восьмёрок, которые тоже могут оказаться в коде. Да и вообще число 8 никак не указывает на то, что это число вертикалей на шахматной доске. Пусть, несмотря на это, нам удалось написать шашечную программу. Но - аппетит приходит во время еды: мы решили взяться за 100-клеточные шашки, а там доска побольше: 10 горизонталей и столько же вертикалей. Придётся просматривать (и очень внимательно!) весь код и исправлять восьмёрки на десятки.

Конечно, лучше сразу объявить две константы:

Const MAX_ROW = 8;

MAX_COL = 8;

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

MAX_ROW = 10;

MAX_COL = 10;

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

Переменные Переменные – это параметры (объекты) программы, которые могут изменять своё значение в ходе выполнения программы.

Физически переменная представляет собой область памяти (её размер зависит от типа переменной; в этих ячейках памяти хранится значение переменной), связанную с её идентификатором.

Как и все другие объекты программы, до первого использования переменные должны быть объявлены. Переменные описываются в разделе объявления переменных модуля или подпрограммы. Он начинается зарезервированным словом var (от слова variable - переменная), за которым следуют объявления переменных.

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

Каждое объявление завершается точкой с запятой:

Var I,i,n: integer;

Flag: boolean:

Ch: char;

X,y,z: single;

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

Типом переменной может быть:

стандартный тип Delphi (integer, single, char...);

- ранее определённый пользователем тип:

Type TNumber= 0..10;

–  –  –

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

Это значит, что все переменные должны быть инициализированы, то есть им должно быть присвоено какое-либо значение (конечно, не при объявлении):

var s: single;

begin s:= 3.1415926;

...

Никогда не используйте неинициализированные переменные!

Впрочем, Delphi следит за вами! После отладочного запуска программы проверяйте содержимое окна сообщений (Рис. У3.1).

Рис. У3.1. Компилятор сообщает об ошибке!

В третьей строке компилятор предупреждает (такое легкомысленное отношение к переменным ошибкой не считается, но использовать её не следует!), что вы забыли задать значение переменной s.

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

Два других сообщения – подсказки: вы объявили переменные, то не использовали их. Возможно, они лишние и их следует удалить.

const num= 123;

pi= 3.1415926;

Flag= TRUE;

var s: single;

begin s:= num;

s:= pi;

s:= flag;

...

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

Рис. У3.2. А это уже серьёзная ошибка!

Глобальные и локальные переменные и константы В программах используют глобальные и локальные переменные.

По крайней мере, одна глобальная переменная существует помимо вашей воли, это переменная главной формы приложения:

var Form1: TForm1;

Мы сравним оба вида переменных, чтобы вы могли осознанно их выбирать в собственных программах.

Глобальные переменные объявляются в секции interface модуля. Локальные – в процедурах и функциях.

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

Глобальные переменные живут «вечно» (точнее – пока не закрыта программа), для них выделяется постоянное место в памяти. Локальные переменные создаются только на время работы подпрограммы, после чего уничтожаются, а память, занимаемая ими, передаётся в общее пользование.

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

Var Имя : тип = значение;

Здесь значение – это константа или константное выражение того же типа, что и переменная.

Например:

Var Seven: integer = 7;

Pi: double= 3.1415926;

Локальные переменные инициализировать при объявлении нельзя.

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

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

Типизированные константы Типизированные константы также объявляются в разделе констант

const и почти так же, как глобальные переменные:

const Имя : тип = значение;

Например:

const Seven: integer = 7;

Pi: double= 3.1415926;

Как работать с компонентами Из компонентов, как из кубиков, собирается вся визуальная (и не только) часть приложения.

Чтобы установить компонент на форме, просто дважды щёлкните на его значке в Палитре компонентов. Он появится в центре формы с установленными по умолчанию размерами (и другими свойствами). Его легко переместить на любое место, взявшись за него мышкой. Размеры визуальных компонентов можно изменить, потянув за один из «узелков», появляющихся по контуру компонента, когда он выделен (Рис. У3.3).

Рис. У3.3. Активный компонент имеет узелки Вид курсора изменяется, когда он находится на габаритном узелке компонента, теперь можно переместить его влево или вправо (а также вверхвниз), изменяя тем самым ширину компонента Аналогично устанавливаются компоненты и на другой контейнер, например, компонент TPanel. Достаточно выделить контейнер и дважды щёлкнуть на значке компонента. Другой способ «расселения» компонентов таков: выделите значок компонента в палитре, щёлкнув на нём, а затем в нужном месте формы (или другого контейнера) нажмите левую кнопку мышки и растягивайте рамку компонента до нужных размеров. Как только вы отпустите мышкину кнопку, компонент появится на форме с заданными размерами (если вы поленитесь «тащиться» по форме, то размеры компонента будут установлены по умолчанию).

Чтобы установить на форме несколько одинаковых компонентов, есть два способа.

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

2. Нажмите клавишу Shift, а затем выделите компонент в Палитре (щёлкните на нём). Вокруг значка возникнет синяя рамка. Теперь щёлкайте мышкой в нужном месте формы. С каждым щелчком на контейнере будет появляться новый компонент. Дабы пресечь этот очаровательный процесс, выберите другой компонент или нажмите стрелку слева от значков компонентов.

Снять выделение с компонента можно, нажав кнопку Deselect the

–  –  –

Палитра компонентов появляется, когда открыто окно Конструктора формы, а не Редактора кода!

На форме имеется сетка из точек – для более точной установки компонентов (Рис. У3.4).

Рис. У3.4. Сетка для компонентов Размеры сетки и привязку к ней вы можете задать в диалоговом окне Options (Рис. У3.5).

Рис. У3.5. Настраиваем размеры сетки Оно появляется после выполнения команды Главного меню Tools Options… Если привязка к сетке включена (установлен флажок Snap to grid), то при перемещении компонентов мышкой они будут выравниваться по узелкам сетки. Оптимальные размеры сетки – 4 х 4 пикселя.

Для задания точных размеров и координат компонента пользуйтесь Инспектором объектов.

Семинар 3. «Здравствуй, мир!», или Первое приложение… усилий Удобно устроившись в среде Delphi, мы просто обязаны бороться с гиподинамией мысли и упадническими настроениями.

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

На предыдущем семинаре нам уже довелось «создать» простейшее приложение – оно само собой возникает при открытии нового проекта и состоит из «пустой» формы (на самом деле у неё есть все основные элементы стандартного окна Windows) и заготовки модуля формы. Это приложение можно запустить, и оно будет работать. Правда, на экране появится только прямоугольное окно, которое можно двигать, сворачивать, изменять его размеры и закрывать. Можно сказать, что простейшее приложение имеет свойства, совершенно необходимые любому приложению Windows, но ничего «лишнего».

Чтобы написать по-настоящему полезное приложение, нужно разместить на форме компоненты, обеспечивающие взаимодействие программы с пользователем (интерфейс), установить их свойства и написать процедуры-обработчики, которые будут выполняться при возникновении тех или иных событий в приложении (функциональная часть программы). Визуальная часть интерфейса приложения создаётся в Конструкторе формы, а его функциональная часть – в Редакторе кода.

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

Запустите Delphi и начните новый проект.

В окне Конструктора формы появится унылая серая форма. Выкрасим её в «зимний», белый цвет. Для этого нажмите в Инспекторе объектов в строке Color кнопочку со стрелкой. Откроется список со стандартными цветами Delphi и Windows. Слева от названия цвета в этом списке имеется и образец (Рис. С3.1).

Рис. С3.1. Выбираем цвет из списка Щёлкните мышкой на строке с белым цветом (clWhite) – и форма станет снежно-белой. Точно так же устанавливается цвет любого визуального компонента.

Вывести надпись на форму можно разными способами. Лучше всего воспользоваться компонентом метка TLabel, специально для этого предназначенным. Найдите в Палитре компонентов значок (он находится на странице Standard) и щёлкните на нём два раза. В середине формы появится этот компонент с надписью Label1. Измените в Инспекторе объектов значение свойства Caption этого компонента на С Новым годом!

(просто введите эту строку в текстовом окошке справа от названия свойства) (Рис. С3.2).

<

Рис. С3.2. Пишем надпись

Поздравление получилось слишком невзрачным, поэтому щёлкните на окошечке свойства метки Font, а затем на кнопке с тремя точками. Откроется диалоговое окно выбора свойств шрифта. Размер задайте побольше, например 40 (такого значения нет в списке размеров, поэтому введите нужное значение в окошечке над списком). Выберите шрифт Times New Roman (или любой другой по вкусу), установите атрибут полужирный и синий цвет. Теперь надпись имеет вполне праздничный вид. Оттащите её мышкой в левый верхний угол формы и размеры формы уменьшите так, чтобы не оставалось слишком много свободного места на форме (ухватите форму за нижний правый угол и перемещайте его вверх влево) (Рис. С3.3).

Рис. С3.3. Надпись готова!

Сохраните проект на диске в новой папке NewYear и запустите программу кнопкой на Панели инструментов. Программа будет скомпилирована, и на экране появится форма с нашим приветствием (Рис. С3.4).

Рис. С3.4. Новогодний привет!

Как видите, она мало чем отличается от той, что мы видели в окне Конструктора формы (исчезла разметочная сетка и изменилась пиктограмма). С этим окном вы можете делать всё, что можно делать с любыми окнами Windows. И это при том, что мы не написали ещё ни одной строчки кода!

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

Выделите на форме компонент Label1 (просто щёлкните на нём мышкой) и в Инспекторе объектов перейдите на страницу Events (щёлкните на табуляторе сверху). Откроется список событий, на которые может реагировать наш компонент. Дважды щёлкните в окошке OnMouseDown, и в нём появится название процедуры, которая будет обрабатывать нажатие кнопки мыши на надписи (Рис. С3.5).

Рис. С3.5. События метки

В окне Редактора кода вы увидите заготовку для этой процедуры:

procedure TForm1.Label1MouseDown(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

begin end;

Конечно, ничего из задуманного нами она делать не будет. Посему добавим ещё две строки кода:

procedure TForm1.Label1MouseDown(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

begin Label1.Font.Color:= clRed;

Label1.Caption:= 'Пошёл на фиг!' end;

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

Чтобы ввести эти строчки, наберите название компонента с точкой – Label1., подождите, пока появится список со свойствами этого компонента, выберите нужный и нажмите клавишу Enter (или дважды щёлкните на нём мышкой) (Рис. С3.6).

Рис. С3.6. Подсказка в действии

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

procedure TForm1.Label1MouseUp(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

begin end;

Чтобы не переписывать весь код заново, скопируйте его в заготовку второй процедуры.

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

–  –  –

Осталось слегка подредактировать текст:

procedure TForm1.Label1MouseUp(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

begin Label1.Font.Color:= clBlue;

Label1.Caption:= 'С Новым годом!' end;

Опять запустите программу. Появится всё то же окно с банальной уже надписью. Зато теперь вы можете «поприкалываться», нажимая кнопку мыши на ней (Рис. С3.7).

Рис. С3.7. Безобразие!

–  –  –

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

Тогда переходите к более сильнодействующим средствам. В свойстве Hint метки напишите Нажми кнопку, а свойство ShowHint установите в True (Рис. С3.9).

Рис. С3.9. Подсказка для курсора Эта подсказка появится, когда мышка замешкается на компоненте. Если и это не поможет, то оставьте свои затеи до лучших времён, когда вы изучите такие возможности Delphi, которые позволят вам подшучивать над кем угодно в самой обидной форме (если вы, конечно, так и не найдёте себе более достойных занятий).

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

procedure TForm1.Label1MouseDown(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

begin Label1.Font.Color:= clRed;

Label1.Caption:= 'Пошёл на фиг!';

Label1.Hint:= 'Отпусти - больно же!' end;

procedure TForm1.Label1MouseUp(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

begin Label1.Font.Color:= clBlue;

Label1.Caption:= 'С Новым годом!';

Label1.Hint:= 'Нажми кнопку!' end;

Lazarus тоже годится для милых розыгрышей (Рис. С3.10).

Рис. С3.10. Новогодний привет от Lazarus‘а

–  –  –

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

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

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

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

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

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

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

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

Именно этим принципиально отличаются процедуры и функции:

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

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

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

procedure имя (список формальных параметров);

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

procedure имя;

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

Объявление функции

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

function имя (список формальных параметров): тип функции;

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

function имя: тип функции;

Описание процедуры Описание процедуры начинается с её заголовка, после чего могут идти (некоторые из них или все могут отсутствовать) точно такие же разделы, что и в основной программе: объявления локальных констант (const), типов (type), переменных (var), меток (label):

procedure Sound(name: PChar);

var s: PChar;

begin //сформировать имя файла:

s:= PChar('wav\'+ name + '.wav');

sndPlaySound(s, SND_ASYNC or SND_FILENAME);

end;

Или procedure TfrmMain.LoadFile; // Заголовок процедуры // Объявления локальных переменных var s : String;

F: TextFile;

i,j: integer;

s1,s2,s3,s4,s5,s6,s7: string;

n,m:integer;

// Операторные скобки begin

–  –  –

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

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

В последних версиях Delphi возвращать значение можно с помощью процедуры exit(значение).

Для примера напишем функцию, вычисляющую факториал числа n.

function fact(n: integer): integer; // Заголовок функции // Объявления локальных переменных var f,i: integer;

begin f:= n;

for i:= n-1 downto 2 do f:= f*i;

fact:= f; // Возвращаемое значение //или //result:= f;

//или //exit(f);

// Конец функции end;

Если вы не вернули значение функции ни одним из описанных способов, то её значение будет неопределённым!

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

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

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

Например, для попискивания вредного персонажа игры мы можем в нужном месте обратиться за помощью к нашей процедуре Sound(name:

String); по извлечению звуков:

Sound('pisk');

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

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

fact(10);

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

Для этого возвращаемое значение присваивают переменной того же типа (или совместимого), что и функция:

Var n: integer;

...

n:= fact(10);

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

Вызов функции называют также обращением к функции.

Фактические параметры перечисляются через запятую.

Локальные и глобальные подпрограммы Все переменные, константы, типы, функции и переменные, объявленные в подпрограмме, являются локальными (то есть местными). Они «видны»

только в подпрограмме и доступны только в её теле. После завершения вызова подпрограммы (все операторы выполнены) они прекращают своё существование.

Если в подпрограмме используются глобальные идентификаторы, то тут имеется одна тонкость: если в подпрограмме объявлен точно такой же идентификатор, что и в главной программе (например, две переменные имеют одно и то же имя), то в подпрограмме будет использоваться именно локальный элемент, а глобальный подпрограмма не увидит вообще и даже знать о нём ничего не будет!

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

Все формальные параметры можно разделить на:

1. параметры-значения;

2. параметры-переменные;

Параметры-значения Все формальные параметры, которые перечислены в заголовке подпрограммы подобным образом Procedure one(a,b,c: integer);

Var n: integer;

Begin n:= a * b*c;

End;

называются параметрами-значениями. В данной процедуре это a,b,c. Такой способ передачи параметров в процедуру называется передачей по значению.

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

Обращение к процедуре one может быть таким:

const WIDTH=10;

var height: integer;

...

height:= 20;

one(WIDTH, height, 2+3);

Если процедура имеет параметры-значения, то для них создаются локальные переменные с именем и типом формальных параметров, после чего в них последовательно копируются значения фактических параметров.

Первый формальный параметр a станет локальной переменной а целого типа со значением первого фактического параметра WIDTH, то есть 10.

Второй – локальной переменной b со значением переменной height, то есть

20. И, наконец, третий - локальной переменной c со значение 5.

После этого выполняется тело процедуры:

n:= 10 * 20 * 5; (n:= a * b * c;) Так как n это локальная переменная, то толку от неё не будет никакого – она умрёт сразу после вычисления значения. В данном случае можно использовать глобальную переменную n, тогда после выполнения процедуры one ей будет присвоено значение 1000.

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

–  –  –

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

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

Например, в процедуре one мы присвоим переменной b значение 1000:

b:= 1000;

При этом переменная height, значение которой копируется в переменную b, не изменится, то есть останется равным 20. Это главное преимущество передачи параметров по значению: подпрограмма получает в своё распоряжение не переменную, а только её значение, поэтому ни одна переменная не пострадает!

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

В некоторых случаях может оказаться недостатком и неспособность процедур изменять значение внешней переменной (ещё недавно мы причислили эту особенность процедур с параметрами-значениями к достоинствам, но такова жизнь: у каждой медали две стороны). Конечно, можно воспользоваться глобальными переменными, но их лучше не упоминать всуе. Но выход всё-таки есть!

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

Procedure two(a,b,c: integer; var n: integer);

Begin n:= a * b * c;

End;

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

В заголовке процедуры формальному параметру n предшествует слово var, значит это параметр-переменная. Такой способ передачи параметров называется передачей по ссылке. Для параметров-переменных локальные переменные не создаются, а вместо значения фактического параметра передаётся адрес переменной, по которому она хранится в памяти. В этом случае в процедуре мы имеем дело именно с той переменной, которая используется при вызове процедуры как фактический параметр, поэтому все изменения формальной переменной n отразятся и на фактическом параметре.

Например, после вызова процедуры Var res: integer;

...

two(WIDTH, height, 2+3, res);

переменная n:= a * b * c; примет значение 1000. Но этот идентификатор n – всего лишь псевдоним переменной res, то есть это значение будет присвоено именно переменной res. Итак, в данном случае n и res – одна и та же переменная, хотя в процедуре она и называется иначе (но вы можете назвать их и одинаково).

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

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

Для этого в панели Desktop (находится в строке Главного меню), в раскрывающемся списке выберите строку Classic Unlocked (Рис. У4.1).

Рис. У4.1. Освобождаем окна

Теперь вы можете перемещать каждое окно по своему усмотрению. Однако Главное окно лучше не трогать. А уж если вы его неосторожно сдвинули, то просто дважды щёлкните на заголовке, и оно вернётся на своё законное место. Остальные окна можно передвигать, раскрывать (максимизировать), сворачивать (минимизировать) и закрывать – как и любые другие окна Windows.

По умолчанию раскладка интерфейса - Default Layout. Чтобы переключиться на неё, выберите в списке соответствующую строку (Рис. У4.2).

Рис. У4.2. Раскладка ИСР Удалить какое-либо окно с экрана можно, нажав кнопку с крестиком в заголовке этого окна. Если через некоторое время окно вам вновь понадобится, то вы можете вернуть его из Главного меню View (Рис. У4.3).

Рис. У4.3. Возвращаеи Палитру инструментов на место Окна в Delphi имеют ещё одну кнопку – с кнопкой (извините за тавтологию!), которая делает окно скользящим – оно самостоятельно задвигается за границу экрана, оставляя только закладку как напоминание о себе.

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

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

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

–  –  –

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

Некоторые, так называемые, специалисты считают, что здоровый человек должен иметь идеальный вес, который можно определить по формуле

–  –  –

где под загадочными буквами А и В скрываются рост (в сантиметрах) и возраст (в годах).

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

Какой же должна быть программа, основанная на этих незамысловатых формулах? Ясно, что главную роль в ней должна играть функция, вычисляющая идеальный вес по заданным параметрам – полу «подопытного индивидуума», его возрасту и росту. С написанием функции проблем не будет, ведь достаточно перевести на «дельфийский» язык обычные математические выражения. Чтобы функция «знала» исходные величины, введём переменные, в которых будем хранить текущие значения возраста и роста.

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

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

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

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

Вот, пожалуй, и вся премудрость. Осталось только воплотить мечту в реальность.

Откроем новый проект.

В заголовке формы напишем Вес, то есть свойству Caption присвоим значение 'Вес'.

Из свойств BorderIcons мы оставим только biSystemMenu и biMinimize, а для BorderStyle выберем bsSingle, чтобы размеры формы нельзя было изменять в работающей программе.

Для выбора пола «клиента» установим компонент RadioGroup со страницы Standard Палитры компонентов (щёлкните дважды на значке ). Он позволяет очень быстро сформировать набор переключателей. В его рамке выведем соответствующую надпись жирным шрифтом (Caption = ' Пол ', Font.Style = [fsBold]), установим форму курсора в виде руки (Cursor = crHandPoint) – прозрачный намёк на то, что здесь нужно приложить руки. Дважды щёлкните на окошке свойства Items и в раскрывшемся редакторе String List Editor наберите две строки (Рис. С4.1).

- мужской

- женский

Рис. С4.1. Редактор строк

Нажмите кнопку ОК – и у компонента появятся два переключателя с этими надписями. Свойство ItemIndex показывает, какой из переключателей выбран (первоначально его значение равно 0 – по умолчанию пол предполагается мужской; суфражистки, феминистки и подкаблучники могут изменить последовательность строк или установить ItemIndex=1).

Чтобы придать интерфейсу элегантный вид, установим на форму компонент Panel, а уже на нём разместим два скроллера.

Первый (Name = sbAge) будет отвечать за возраст, второй (Name = sbRost)

- за рост. Выберем по изложенным выше причинам для обоих ползунков курсор в виде руки (Cursor = crHandPoint). Дополнительно сделаем подсказки (Hint = 'Возраст' и Hint = 'Рост', ShowHint = True). Будем считать, что возраст изменяется в пределах от 0 до 100 (Min = 0, Max = 100, значение по умолчанию Position = 20), а рост от 60 до 220 (Min = 60, Max = 220, значение по умолчанию Position = 160).

Справа от скроллеров разместим две метки (lblAge и lblRost), в которые будем выводить текущие значения возраста и веса. Шрифт установим покрупнее (Font.Height = -16), потолще (Font.Style = [fsBold]) и поярче (Font.Color = clRed). В каждой метке напишем значения по умолчанию (Caption = '20' и Caption = '160'). Чтобы числа всегда были расположены строго друг под другом, установите Alignment = taRightJustify и AutoSize = False. Осталось справа от них поместить две метки, поясняющие назначение скроллеров. Забегая немного вперёд, мы должны увидеть такую картину (Рис. С4.2).

Рис. С4.2.

Весовой интерфейс Осталось самое «главное» - установить на форме пару меток для вывода вычисленного значения идеального веса:

Метка lblVes: Caption = '52', Font.Color = clRed, Font.Height = -32, Font.Style = [fsBold] Метка Label2: Caption = 'Идеальный вес =', Font.Height = -19, Font.Style = [fsBold].

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

Как мы уже выяснили, нам потребуются две переменные для хранения введённых значений возраста и веса. Объявим их сразу перед разделом

implementation:

var Form1: TForm1;

age, rost: integer;

Рядышком объявим функцию, которая по «учёным» формулам будет вычислять вес:

private { Private declarations } function Ves: single;

Что до самой формулы, то исключительно вручную наберите её код:

//ВЫЧИСЛИТЬ ИДЕАЛЬНЫЙ ВЕС

function TForm1.Ves: single;

begin if RadioGroup1.ItemIndex= 0 then //мужской пол Result:= (rost*3 - 450 + age) * 0.25 + 45 else //женский пол Result:= (rost*3 - 450 + age) * 0.225 + 40.4;

//скорректировать отрицательные значения:

if Result 0 then Result:= 4;

end;

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

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

Мы поступим правильно, если при запуске программы сразу же выведем значение веса по установкам скроллеров (в Инспекторе объектов перейдите на страницу Events и дважды щёлкните на окошечке события OnCreate, а затем в заготовке процедуры обработки напишите следующие строки):

//СОЗДАТЬ ФОРМУ procedure TForm1.FormCreate(Sender: TObject);

begin //снять значения со скроллеров:

age:= sbAge.Position;

Rost:= sbRost.Position;

//вычислить вес:

lblVes.Caption:= inttostr(round(ves)) end;

Конечно, можно сразу же во всех метках вывести согласованные значения, но если вы потом измените одно из них, то либо придётся исправлять и вес, либо при запуске программы вес не будет соответствовать положениям движков. Ничего страшного в этом нет – вряд ли вы угадаете возраст и рост пользователя, он всё равно будет двигать ползунки, - но лучше приучить себя всё доводить до ума.

Запустив эту программу, «клиент» будет вводить свои данные, то есть пол, возраст и вес. Чтобы не заставлять его нажимать после этого кнопку для вычисления веса, будем «публиковать» его сразу после каждого изменения параметров.

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

//ВЫБРАТЬ ПОЛ procedure TForm1.RadioGroup1Click(Sender: TObject);

begin //вычислить вес:

lblVes.Caption:= inttostr(round(ves)) end;

Аналогично поступаем и при изменении положения ползунка скроллера:

//ЗАДАТЬ ВОЗРАСТ procedure TForm1.sbAgeChange(Sender: TObject);

begin //возраст:

age:= sbAge.Position;

//вывести значение на экран:

lblAge.Caption:= inttostr(age);

//вычислить вес:

lblVes.Caption:= inttostr(round(ves)) end;

//ЗАДАТЬ РОСТ procedure TForm1.sbRostChange(Sender: TObject);

begin //рост:

Rost:= sbRost.Position;

//вывести значение на экран:

lblRost.Caption:= inttostr(Rost);

//вычислить вес:

lblVes.Caption:= inttostr(round(ves)) end;

Значения возраста и роста определяем по положению ползунка (свойство Position компонента ScrollBar), вычисляем вес, округляем его до целого числа (формулы, естественно, не настолько точны, чтобы рассчитывать ещё и граммы), которое преобразуем в строку и выводим на экран.

Перед тем как предлагать эту программу другим людям, очень полезно испытать её на себе. Запустите программу, подвигайте ползунки, оцените все достоинства и недостатки интерфейса (Рис. С4.3). И – непременно! – постарайтесь её улучшить.

Рис. С4.3. Вес взят!

–  –  –

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

Дотошная наука выяснила, что тело молодых здоровых мужчин содержит около 15%, а тело женщин – 22% жира.

Жирность произвольно выбранного тела приблизительно оценивается по формуле:

–  –  –

где Р – идеальный вес, который определяется по предыдущим формулам.

Не будем целиком переписывать всю программу Вес, а адаптируем её к «новым реалиям». Для этого создадим новую папку Zhir, в которую перепишем файлы формы и программы (Главное меню File Save as…, затем

File Save Project as…). В файле модуля формы добавим ещё одну переменную – для хранения веса тела:

var Form1: TForm1;

age, rost, ves: integer;

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

private { Private declarations } function Zhir: single;

Основательно поработаем и над самой функцией:

–  –  –

v:= (rost*3 - 450 + age) * 0.225 + 40.4;

Result:= (ves - v) / ves * 100 + 22 end;

//скорректировать значения:

if Result 0 then Result:= 0;

if Result 100 then Result:= 100;

end;

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

На форму «придётся» добавить ещё один скроллер – для ввода истинного веса тела:

Name = sbVes Cursor = crHandPoint Hint = 'Вес' Max = 200 Min = 3 Position = 60 ShowHint = True и метку:

Name = lblVes Alignment = taRightJustify AutoSize = False Caption = '100' Font.Color = clRed Font.Height = -16 Font.Style = [fsBold] Остальные изменения внесите сами, поглядывая на картинку (Рис. С4.4).

Рис. С4.4. «Жирный» интерфейс Не забудьте прежнюю метку lblVes переименовать в lblZhir.

Осталось подправить код модуля (выделенные строки):

//СОЗДАТЬ ФОРМУ procedure TForm1.FormCreate(Sender: TObject);

begin //снять значения со скроллеров:

age:= sbAge.Position;

Rost:= sbRost.Position;

Ves:= sbVes.Position;

//вычислить жирность:

lblZhir.Caption:= inttostr(round(zhir)) end;

//ВЫБРАТЬ ПОЛ procedure TForm1.RadioGroup1Click(Sender: TObject);

begin //вычислить жирность:

lblZhir.Caption:= inttostr(round(zhir)) end;

//ЗАДАТЬ ВОЗРАСТ procedure TForm1.sbAgeChange(Sender: TObject);

begin //возраст:

age:= sbAge.Position;

//вывести значение на экран:

lblAge.Caption:= inttostr(age);

//вычислить жирность:

lblZhir.Caption:= inttostr(round(zhir)) end;

//ЗАДАТЬ РОСТ procedure TForm1.sbRostChange(Sender: TObject);

begin //рост:

Rost:= sbRost.Position;

//вывести значение на экран:

lblRost.Caption:= inttostr(Rost);

//вычислить жирность:

lblZhir.Caption:= inttostr(round(zhir)) end;

//ЗАДАТЬ BEC procedure TForm1.sbVesChange(Sender: TObject);

begin //вес:

ves:= sbVes.Position;

//вывести значение на экран:

lblVes.Caption:= inttostr(Ves);

//вычислить жирность:

lblZhir.Caption:= inttostr(round(zhir)) end;

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

–  –  –

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

–  –  –

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

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

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

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

После нажатия на кнопку btnPop Сказочка, мы попадём в обработчик события:

procedure TForm1.btnPopClick(Sender: TObject);

var n: integer;

begin n:= speIter.Value;

pop(n);

listbox1.TopIndex:=listbox1.

Items.Count-1;

end;

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

А вот и сама сказочка:

procedure pop(n: integer);

begin if n = 0 then exit;

Form1.listbox1.

Items.Add('У попа была собака, он её любил,');

Form1.listbox1.

Items.Add('Она съела кусок мяса, он её убил.');

Form1.listbox1.

Items.Add('В землю закопал и надпись написал:');

Form1.listbox1.

Items.Add('');

pop(n-1);

end;

В первой строке как раз и находится обязательное условие, гарантирующее завершение сказочки. Как только параметр n станет равным нулю, процедура закончится. Но до этого она будет напечатана 1 раз, а затем вызовет себя pop(n-1);

для повторения сказки на 1 раз меньше. Таким образом, процедура будет вызвана 5 раз (если вы не изменили начальное значение):

pop(4);

pop(3);

pop(2);

pop(1);

pop(0);

На последнем вызове сработает первая строка, и страдания читателя сих милых строк закончатся (Рис. У5.1).

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

Рис. У5.1. Тут и сказочке конец!

–  –  –

Перейдём теперь к несказочной рекурсии – к классическому примеру вычисления факториала.

Интерфейс программы можно позаимствовать у предыдущего примера, с небольшими исправлениями (Рис. У5.2).

Рис. У5.2. Вычисляем факториалы Здесь всё также начинается с задания количества повторов в окошечке Factorial, это как раз и будет то число, для которого мы будем вычислять факториал. Дополнительно засекаем время работы функции factorial, хотя на современных компьютерах это всегда будет 0.

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

//Рекурсивное вычисление факториала procedure TForm1.btnFactorialClick(Sender: TObject);

var time,time0: single;

n: integer;

//k: longword;

k: int64;

s: string;

begin time0:=GetTickCount(); //засечь начало time:=time0;

n:= speFactorial.Value;

listbox1.items.

add('Вычисляем факториал ' + inttostr(n));

k:=factorial(n);

listbox1.items.

add('Факториал ' + inttostr(n) + ' = ' + inttostr(k));

time0:=(GetTickCount()-time0)/1000;

str(time0:6:3,s);

listbox1.items.

add('Time ' + s + ' s');

listbox1.items.

add('');

listbox1.TopIndex:=listbox1.

Items.Count-1;

end;

А вот как просто рекурсивно вычисляется факториал – всего 2 строки кода:

function factorial (n: integer): int64;

begin if n = 0 then factorial:= 1 else factorial:= factorial(n-1)*n;

end;

Сравните её с той функцией, что мы рассматривали ранее. Обратите внимание на первую строку, где проверяется условие завершения рекурсии!

Исходный код программы находится в папке factorial.

Рекурсивные подпрограммы выглядят очень красиво, «профессионально», однако не стоит ими злоупотреблять – практически всегда можно решить задачу и без рекурсии (но не всегда это решение будет проще). С помощью рекурсии следует решать задачи, в которых требуется многократно выполнить сходные действия. При этом должно существовать нерекурсивное решение для самого простого из этих действий, которое и будет служить условием завершения рекурсии. Часто рекурсию используют для решения комбинаторных задач с полным или частичным перебором: обход лабиринта, расстановка ферзей, генерирование перестановок чисел, головоломка Ханойские башни.

–  –  –

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

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

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

Например, в режиме конструирования формы одиночный щелчок на названии компонента выделяет его на форме (Рис. У5.3).

Рис. У5.3. Одним щелчком мыши можно выделить кнопку на форме Обратите внимание, что в окне Инспектора объектов этот компонент становится активным, и вы можете изменять его свойства.

Установите курсор на объявлении процедуры, функции, метода в разделе interface вашего модуля и нажмите клавиши Ctrl+Shift+Up или Ctrl+Shift+Down (клавиши со стрелками). Вы тут же окажетесь в разделе implementation, где находится их код. И наоборот, повторное нажатие этих комбинаций клавиш перенесёт вас в мгновение ока в раздел interface, на объявление процедуры.

При наведении курсора на любой объект исходного кода рядом появляется информация о нём (Рис. У5.4).

Рис. У5.4. Подсказка Щёлкнув по ссылке, вы перейдёте к его объявлению.

В любой строке текста можно установить закладку. Для этого следует выполнить команду контекстного меню Toggle Bookmarks и щёлкнуть на любой из десяти закладок или нажать комбинацию клавиш Ctrl + Shift + 0..9 (цифра обозначает номер закладки). Слева от строки текста с курсором появится зелёная книжка. В Delphi все закладки сохраняются вместе с файлом и затем восстанавливаются при повторной загрузке файла!

Для перехода к нужной закладке используйте команду контекстного меню Goto Bookmarks или клавиши Ctrl + 0..9.

Убрать закладку можно той же командой Toggle Bookmarks.

Если у вас хорошая память, то попробуйте запомнить номер нужной строки (он, конечно, может и измениться, если вы добавите код). Вы вернётесь к ней по команде Главного меню Search Go to Line Number (или Alt+G), указав в диалоговом окне номер строки (Рис. У5.5).

Рис. У5.5. Переходим в заданную строку Ещё больше возможностей предоставляет команда Главного меню Search Find (она же Ctrl+F). Установите курсор на нужный идентификатор (или любое слово) и выполните указанную команду. Под окном Редактора кода появится диалог, в текстовом окне которого будет ваше слово (можно и просто набрать нужное слово) (Рис. У5.6). Нажмите кнопку со стрелкой, и курсор переместится на «первое попавшееся» указанное слово в тексте.

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

Рис. У5.6. Тотальный поиск Все введённые слова запоминаются, поэтому для повторного поиска достаточно выбрать нужное слово в раскрывающемся списке, который появляется, если нажать на кнопку со стрелкой справа от окна ввода текста.

И ещё одна возможность перехода через альпы кодовых строк. Установите курсор на названии процедуры в разделе implementation, вызовите контекстное меню Редактора кода и выполните команду Find Declaration (Рис. У5.7), чтобы оказаться в разделе interface, где находится объявление данной процедуры (Рис. У5.8).

Рис. У5.7. Переходим к процедуре Рис. У5.8. Можно работать!

И только попробуйте теперь заблудиться!

–  –  –

Для сравнения итерационных и рекурсивных процедур напишем две родственные программы из школьной жизни – для вычисления НОД (наибольшего общего делителя двух чисел) и НОК (наименьшего общего кратного). Они должны быть вам хорошо известны (если это не так, сходите, наконец, в школу!).

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

Для определения времени нам потребуются две подпрограммы:

var Form1: TForm1;

time,time0: single;

procedure TimeOn;

begin time0:=GetTickCount(); //засечь начало end;

function TimeOut: string;

var s: string;

begin time:=(GetTickCount()-time0)/1000;

str(time:6:3,s);

Result:= s;

end;

Для запуска соответствующих подпрограммм установим две кнопки:

btnIter с надписью ИТЕРАЦИИ и sbtRecurs с надписью РЕКУРСИЯ.

Первая, как следует из названия, запускает итерационный цикл, вторая – рекурсивный:

procedure TForm1.btnIterClick(Sender: TObject);

var n1,n2: integer;

i: integer;

begin n1:= strtoint(txtNum1.Text);

n2:= strtoint(txtNum2.Text);

TimeOn;

for i:= 1 to strtoint(txtNumLoop.Text) do NOD(n1,n2);

lblTime.Caption:= TimeOut;

lblRes.Caption:= inttostr(NOD(n1,n2));

end;

procedure TForm1.sbtRecursClick(Sender: TObject);

var n1,n2: integer;

i: integer;

begin n1:= strtoint(txtNum1.Text);

n2:= strtoint(txtNum2.Text);

TimeOn;

for i:= 1 to strtoint(txtNumLoop.Text) do NODR(n1,n2);

lblTime.Caption:= TimeOut;

lblRes.Caption:= inttostr(NODR(n1,n2));

end;

Сами функции для вычисления НОД достаточно просты:

//Вычисление наибольшего общего делителя //двух чисел типа integer //Итерационное вычисление НОД function NOD(n1,n2: integer): integer;

//n1 = n2 = 0;

var temp: integer;

begin if n1 n2 then swap(n1,n2);

if n2=0 then result:= n1 else begin while n20 do begin temp:= n1 mod n2;

n1:=n2;

n2:= temp;

end;

result:=n1;

end;

end;

//Рекурсивное вычисление НОД function NODR(n1,n2: integer): integer;

begin if n1 n2 then result:=NODR(n2,n1) else if n2=0 then result:= n1 else result:= NODR(n2,n1 mod n2);

end;

Найдите в функции NODR условие выхода из рекурсии!

Алгоритм, реализованный в функции NODR, кажется очень простым, но это обманчивая простота, поэтому рассмотрим его подробнее. Для определённости будем считать, что нужно найти НОД чисел n1=15 и n2=21.

1. Для вычислений важно, чтобы первое число было не меньше второго.

Если это не так, то в строке if n1 n2 then result:=NODR(n2,n1) числа переставляются, и функция NODR вызывается с правильным порядком аргументов. Для наших чисел n1 n2, поэтому будет вызвана функция NODR(n2,n1), то есть NODR(21,15). Важно понять, что как числа ни переставляй, первое из них – это n1, а второе - n2, поэтому в самой функции n1=21, а n2=15!

Теперь условие n1 = n2 точно выполняется.

2. В случае, если второе число меньше нуля или равно нулю, НОД равен первому числу и вычисления заканчиваются:

if n2=0 then result:= n1 Возможно, это условие будет верным и сразу, а если нет, то будет выполняться строка result:= NODR(n2,n1 mod n2);

Мы видим, что большим числом становится n2 (которое было меньшим в предыдущем обращении к функции), а меньшим – остаток от деления большего числа на меньшее (очевидно, что n2 не может быть меньше остатка).

Для наших чисел условие n2=0 (15 =0) неверное, так что будет исполняться строка result:= NODR(15, 21 mod 15); или result:= NODR(15, 6);

и вычисления продолжатся с начала п.2.

3. Так как n2 (15) больше нуля, то ещё раз будет выполнена строка result:= NODR(n2,n1 mod n2); или result:= NODR(6, 15 mod 6); или result:= NODR(6, 3);

Опять переходим к п.2, а затем к п.3:

result:= NODR(n2,n1 mod n2); или result:= NODR(3, 6 mod 3); или result:= NODR(3, 0);

Снова переходим к п.2. Теперь условие if n2=0 then result:= n1 выполнено и функция возвращает НОД – число 3.

Как видите, параметр n2 рано или поздно станет равен нулю, и рекурсия неизбежно закончится в строке if n2=0 then result:= n1, которая и является условием завершения рекурсии.

Рис. С5.1. «Итерации» - «Рекурсия»: счёт 1 : 1!

Для более точного сравнения итерационного и рекурсивного методов, понажимайте на кнопки по нескольку раз, потому что в системе Windows одновременно выполняется множество процессов, так что время может несколько отличаться в разных «попытках». Более того, результаты зависят и от чисел, для которых вычисляется НОД (Рис. С5.1).

–  –  –

Наименьшее общее кратное

На самом деле НОК просто вычисляется через НОД по такой формуле:

НОК = n1 * n2 div НОД (n1,n2), так что нам достаточно дополнить предыдущую программу двумя функциями, которые реализуют эту формулу:

//Итерационное вычисление НОK function NOK(n1,n2: integer): integer;

var temp: integer;

begin temp:= n1 * n2;

if temp = 0 then result:= 0 else result:= temp div NOD(n1,n2);

end;

//Рекурсивное вычисление НОK function NOKR(n1,n2: integer): integer;

var temp: integer;

begin temp:= n1 * n2;

if temp = 0 then result:= 0 else result:= temp div NODR(n1,n2);

end;

Казалось бы, и здесь скорость вычислений должна быть одинакова, но рекурсивный способ всё-таки уверенно выигрывает (Рис. С5.2).

Рис. С5.2. А в этом «матче» «Рекурсия» выиграла! Счёт 2 : 1!

–  –  –

Название «простые типы данных» обусловлено тем, что они не содержат «в себе» никаких других типов данных.

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

Целые типы Самые «востребованные» типы данных! Можно смело утверждать, что ни одна программа не обходится без них. Именно этим и объясняется такое обилие целых типов данных в Delphi.

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

Большинство типов могут хранить числа со знаками, но типы byte и Longint - только неотрицательные числа. Другое принципиальное отличие целых типов заключается в максимальной и минимальной величине чисел, которые они содержат. Естественно, чем эти значения больше, тем больше памяти потребуется для их хранения. Кроме того, операции с «родными» целыми типами – Integer и cardinal - Delphi работает быстрее всего. Таким образом, при выборе целого типа данных для своих переменных вы должны руководствоваться именно этими соображениями. Если коротко: всегда выбирайте типы Integer и cardinal, если у вас нет веских аргументов в пользу других типов данных.

Итак, выбираем тип данных по душе:

–  –  –

Объявление переменных целого типа:

Var i,j: integer;

C: cardinal;

B: byte;

W: word;

Значения переменным целого типа иногда удобнее задавать не десятичными, а 16-ричными числами:

B:= 255; или B:= $FF;

w:= 2009; или w:= $000007D9;

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

Большое преимущество целых типов перед вещественными состоит не только в том, что процессор быстрее их «переваривает», но прежде всего в том, что они всегда хранят точные значения, а вещественные – приближённые.

Вещественные типы (Действительные типы) Значение переменных вещественного типа всегда приблизительные, поэтому их нельзя проверять на равенство!

–  –  –

Тип Real48 оставлен только для совместимости с предыдущими версиями Delphi, поэтому его не следует использовать.

Типы Comp и Currency используются только в денежных операциях.

Обычно для расчётов хватает точности типа Single, но вычисления производятся быстрее с типом Real (он же Double).

Для записи вещественных чисел используют 2 способа.

Первый – как в школе, но вместо десятичной запятой ставится точка:

1.5

-3.14 Для очень больших и очень маленьких чисел больше подходит второй способ. Сначала записывается однозначное число с десятичной точкой, затем буква E (или e) и целое число, которое равно степени десятки. Например,

1.05e2 это 1.05 x 102 или 1.05 x 100 = 105

-3.14e-5 это -3.14 x 10-5 или -3.14 x 0,00001 = -0.0000314

Объявление переменных вещественного типа:

Var a,b: Single;

C: Real;

Вещественные числа часто используются для «технических» расчётов, а при необходимости их можно округлить до целых чисел (тип результата int64) с помощью функций trunc и round.

Целым переменным нельзя присваивать действительные значения!

Функция trunc просто отсекает дробную часть числа:

trunc(2.1728) = 2 trunc(-2.1728)) = -2

Функция round округляет действительное число до ближайшего целого:

round(2.1728) = 2 round(2.7) = 3 round(2) = 2 round(-2.1728)) = -2 Чтобы было легче понять, как действует функция round, выразим её через

trunc:

round(x) = trunc(x + 0.5), если x=0 round(x) = trunc(x - 0.5), если x 0 Перечисляемый тип Определяется списком идентификаторов, которые перечисляются через запятую в круглых скобках. Поскольку этот список формирует сам программист, он должен объявить новый тип.

Например, тип Autos может содержать марки любимых автомобилей:

Type Autos = (Mazda, Toyota, Opel, BMW, Volkswagen);

Далее мы можем объявить переменную этого типа:

Var MyAutos: autos;

Но можно и сразу объявить переменную перечисляемого типа вот так:

Var MyAutos: (Mazda, Toyota, Opel, BMW, Volkswagen);

Значением переменной MyAutos могут быть Mazda, Toyota, Opel, BMW, Volkswagen и только они! Если вы купили (или богатый папа подарил) мерседес, то вам придётся подправить объявление типа, а вот с демократичным фольксвагеном не будет никаких проблем:

MyAutos:= Volkswagen;

Присвоили переменной нужное значение – и на дорогу с чистой совестью.

Функция Ord возвращает порядковый номер идентификатора (его числовое значение) в списке:

ord(Mazda) 0 ord(Volkswagen) 4 Будьте внимательны: нумерация начинается с нуля!

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

Mazda Toyota Opel BMW Volkswagen Идентификаторы в перечисляемом типе не могут быть использованы для наименования других переменных!

Логический тип Это перечисляемый тип, который содержит только 2 элемента: TRUE и FALSE, поэтому логические переменные могут принимать только эти 2 значения. Для их хранения достаточно 1 байта.

Как для перечисляемого типа FALSE TRUE Ord(FALSE) = 0 Ord(TRUE) = 1 succ(FALSE) = TRUE pred(TRUE) = FALSE

Объявление переменных логического типа:

var a,b,c: boolean;

Тип ByteBool эквивалентен типу boolean. WordBool занимает в памяти 2 байта, а LongBool – 4. Эти логические типы используются крайне редко.

Интервальный тип (тип-диапазон, ограниченный тип) Определяет программист на основе любого простого порядкового типа.

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

Объявление интервальных типов:

Type hours = 0..23;

letters= 'a'..'z';

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

Переменные этих типов объявляются, как обычно:

Var Hour: hours;

Letter: letters;

Если встреча запланирована на 21 час, мы можем запомнить это событие так:

Hour:= 21;

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

Символьные типы Основной символьный тип в Delphi – Char. Он определяет набор символов Юникода с кодами 0.. 65535, поэтому для хранения значений использует два байта. В последних версиях Delphi тип Char эквивалентен типу WideChar (прежде это был тип AnsiChar).

Код любого символа можно узнать с помощью функции ord:

ord('1') = 49 ord('S')= 83 ord('Ы')= 219 Cимволы сравниваются по их кодам, поэтому 'Ы' ' S '.

Функция chr, наоборот, возвращает символ с заданным кодом:

chr(49) = '1' chr(83)='S' chr(219)='Ы' Тип AnsiChar определяет набор символов ASCII с кодами 0..255, поэтому для хранения значений достаточно одного байта. Первые 128 символов этих типов всегда одинаковы, а остальные зависят от локальных настроек компьютера. Например, если у вас установлена русская версия Windows, то это символы русского алфавита.

Объявление переменных символьного типа:

var a,b,c: char;

Некоторые языки содержат значительно больше знаков, чем оставшиеся 128 символов, поэтому для их хранения в памяти требуется 2 байта. Тип WideChar содержит 65535 символов, что вполне достаточно даже для китайских иероглифов.

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

Pred – функция, которая возвращает предыдущее значение выражения порядкового типа, указанного в скобках:

Pred(2) = 1 Pred('2') = '1' Pred(True) = False Pred(Volkswagen) = BMW

Succ - функция, которая возвращает следующее значение:

Succ(1) =2 Succ('1') = '2' Succ(False) = True Succ(BMW) = Volkswagen Легко заметить, что действие этой функции противоположно действию функции Pred, и наоборот.

Ord - функция, которая возвращает порядковый номер значения в списке:

Ord('A') = 65 Ord(True) = 1 Ord(Volkswagen) = 4 Low - функция, которая возвращает минимальное значение указанного типа данных:

Low(Integer) = -2147483648 Low(Boolean) = False Low(Char) = #0 (символ с кодом 0) High - функция, которая возвращает максимальное значение указанного типа данных:

High(Integer) = 2147483647 High(Boolean) = True High(Char) = (символ с кодом #$FFFF) С помощью этих двух функций вы легко сможете определять диапазон значений любого порядкового типа.

Ну, и ещё две процедуры, с которыми мы уже знакомы:

Dec – функция декремента; уменьшает значение переменной типа integer на единицу:

Var n: integer;

n:= 2;

После выполнения функции Dec(n) значение переменной n станет равным 1.

Можно уменьшить значение переменной на любое целое число:

Dec(n, 3) n= -1

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

n:= n – 1; или n:= n – 3;

но выполняется быстрее.

Inc – процедура инкремента; увеличивает значение на единицу.

Var n: integer;

n:= 2;



Pages:   || 2 | 3 | 4 | 5 |   ...   | 12 |
Похожие работы:

«Негосударственное частное учреждение – образовательная организации высшего образования "МИССИОНЕРСКИЙ ИНСТИТУТ" теологический факультет кафедра социально-гуманитарных дисциплин ЛАТИНСКИЙ ЯЗЫК Программа дисциплины Екатеринбург Одобрено на заседании кафедры от 30 сентября 2015 г. № 7 I. ПАСПОРТ ДИСЦИПЛИНЫ Направление подготовки: 48.03.0...»

«АДМИНИСТРАЦИЯ ГОРОДА ВЛАДИМИРА Протокол вскрытия конвертов с заявками на участие в открытом конкурсе № 2-В Место вскрытия конвертов: 600000, г.Владимир, ул.Горького, д.36 Дата и время вскрытия конвертов: 18.01.2011 09 ч 00 мин. по московскому времени Повестка дня: Вскрытие конвертов с заявками на участие в открытом конкурсе на...»

«Справочное руководство по работе с оборудованием ПК HP EliteOne 800 G2 All-in-One Business PC c размером дисплея 23 дюйма ПК HP EliteOne 705 G2 All-in-One Business PC c размером диспле...»

«31.10.2014 Решения Общих собраний акционеров Эмитент: Открытое акционерное общество Санкт-Петербургская биржа ИНН 7801268965 ОГРН 1097800000440 Адрес: 127006, Российская Федерация, г.Москва, ул. Долгоруковская, д. 38, стр. 1. Да...»

«Программа составлена на основе следующих нормативно-правовых актов: Федеральный закон " Об образовании в Российской федерации" от 29 декабря 2012 года № 273-ФЗ; Приказ Министерства образования и науки Российской Федерации от 31....»

«Руководство по интерфейсу командной строки UPS Network Management Card 2 AP9630, AP9631, AP9635 990-4879C-028 08/2016 Правовая оговорка компании Schneider Electric Корпорация Schneider Electric не гарантирует надежность, полноту и безошибочность представленной в настоящем руководстве информации. Данное издание не является замено...»

«УДК 821.161.1-31 ББК 84(2Рос=Рус)6-44 Н59 Любое использование материала данной книги, полностью или частично, без разрешения правообладателя запрещается. Оформление обложки — Екатерина Ферез Внутреннее оформление — Ирина Гришина Нечаева, Наталья Георгиевна.Н59 Внук котриарх...»

«Гаагский акт от 28 ноября 1960 г. СОДЕРЖАНИЕ Статья 1: Учреждение Союза Статья 2: Определения Статья 3: Право на международное депонирование Статья 4: Депонирование в Международном бюро или через национальные ведомства Статья 5: Виды депонирования; содержание заявки Статья 6: Международный реестр образцо...»

«РОССИЙСКАЯ ФЕДЕРАЦИЯ (19) (11) (13) RU 2 572 449 C1 (51) МПК A47C 4/02 (2006.01) ФЕДЕРАЛЬНАЯ СЛУЖБА ПО ИНТЕЛЛЕКТУАЛЬНОЙ СОБСТВЕННОСТИ (12) ОПИСАНИЕ ИЗОБРЕТЕНИЯ К ПАТЕНТУ На основании пункта 1 статьи 1366 части ч...»

«Vestnik policii, 2015, Vol.(3), Is. 1 Copyright © 2015 by Academic Publishing House Researcher Published in the Russian Federation Vestnik policii Has been issued since 1907. ISSN: 2409-3610 Vo...»

«УДК 82-3 К 84(2Р -Р )6-4 К 14 Ка а ц в К. К 14 /К К.—.:Э, 2014. — 352. — (К. ISBN 978-5-699-68789-3 К. – –.., : " ". :,. ДК 82-3 ББК 84(2Р -Р )6-4 ©Ч ва., 2014 ©О. ООО "И а ьв ISBN 978-5-699-68789-3 "Э ", 2014 лава 1 В том, как он держал оружие, чувствовался выработанный годами и обстоятельствами навык: "Вепрь" в левой руке, италь...»

«Прайс-лист на услуги мобильной связи Для корпоративных клиентов ОАО "МегаФон" – юридических лиц и индивидуальных предпринимателей с любым количеством абонентских номеров Тарифный план "Корпоративный безлимит" с опциями "L 500", "L 1000", "L 3000" Для местных, междугородных звонков и поездок по России Для клиенто...»

«1 Содержание Введение.. 4 1. Структура факультета, выпускающих кафедр и система их 8 управления. Организационно-правовое обеспечение образовательной деятельности по специальности..2. Структура подготовки специалистов. 18 2.1.Контингент студентов.. 18 2.2. Приём студентов.. 19 3. Содержание подготов...»

«Наталия Борисовна Правдина Большая книга женского счастья Серия "Лучшие практики от Мастера Счастливой жизни (АСТ)" Текст предоставлен правообладателем http://www.litres.ru/pages/biblio_book/?art=8682349 Большая книга женского счастья : ACT; Москва; 2014 ISBN 978-5-17-087357-9 Анно...»

«ГРАЖДАНСКОЕ ДЕЛО (Жилищные споры): О ПРИЗНАНИИ ЛИЦА НЕ ПРИОБРЕТШИМ ПРАВО ПОЛЬЗОВАНИЯ ЖИЛЫМ ПОМЕЩЕНИЕМ Обстоятельства дела: К адвокату Матвею Конышеву за консультацией обратились М.Л.Ф. (мать, наниматель жилого помещения), М.В.В. (отец) и М.К.В. (сын), предъявили для ознакомления Повестку в суд (явиться в...»

«6 марта 2006 года N 35-ФЗ РОССИЙСКАЯ ФЕДЕРАЦИЯ ФЕДЕРАЛЬНЫЙ ЗАКОН О ПРОТИВОДЕЙСТВИИ ТЕРРОРИЗМУ Принят Государственной Думой 26 февраля 2006 года Одобрен Советом Федерации 1 марта 2006 года (в ред. Федерального закон...»

«ЧАСТНОЕ УЧРЕЖДЕНИЕ ОБРАЗОВАНИЯ " М И Н С К И Й И Н С Т И Т У Т У П РА ВЛ Е Н И Я " УТВЕРЖДАЮ Ректор Минского института управления Суша Н.В. Регистрационный № УД-/р. Математические методы в психологии Учебная программа д...»

«Прайс-лист на услуги мобильной связи Для корпоративных клиентов ПАО "МегаФон" – юридических лиц и индивидуальных предпринимателей с любым количеством абонентских номеров Тарифный план "Корпоративный безлимит" с опцие...»

«Зарегистрировано в Национальном реестре правовых актов Республики Беларусь 13 июля 2007 г. N 8/16811 ПОСТАНОВЛЕНИЕ МИНИСТЕРСТВА ПО ЧРЕЗВЫЧАЙНЫМ СИТУАЦИЯМ РЕСПУБЛИКИ БЕЛАРУСЬ 26 июня 2007 г. N 61 ОБ УТВЕРЖДЕНИИ ИНСТРУКЦИИ ПО ТУШЕНИЮ ПОЖАРОВ...»

«Тихомиров А.В. Деформация институциональной среды сферы охраны здоровья // Главный врач: хозяйство и право. – 2014. – № 5. – С.3-9. Alexey V.Tikhomirov. Health care institutional environment deformation Резюме: Разумная "сквозная" институционализация сферы охраны здоровья способна устранить ее нынешнюю дефективность при создании основанной на пр...»

«Сергей Ка Ваши руки хотят вас вылечить Текст предоставлен правообладателем http://www.litres.ru/pages/biblio_book/?art=9094635 Ваши руки хотят вас вылечить: Аннотация Ваши руки хотят вас вылечить. Не только хотят, но и могут. И всегда могли. И эта кни...»

«Андре Конт-Спонвиль Философский словарь Текст предоставлен правообладателем http://www.litres.ru/pages/biblio_book/?art=9362050 Конт-Спонвиль, Андре Философский словарь: Этерна; Москва; 2012 ISBN 978-5-480-00288-1 Аннотация Философский словарь известнейшего современного французского философа. Увлекательная книга о человеке, о...»

«DanVex DEH 500i Осушитель воздуха Эксплуатация Технология DanVex Oy Инструкция по эксплуатации. Внимательно ознакомьтесь с настоящей инструкцией перед началом монтажа / эксплуатации данной установки! Наша гарантия аннулируется и теряет юридическую силу, если установка непра...»

«Ирина Вечерская 100 рецептов вегетарианских блюд. Вкусно, полезно, душевно, целебно Серия "Душевная кулинария" Текст предоставлен правообладателем http://www.litres.ru/pages/biblio_book/?art=11642766 100 рецептов...»








 
2017 www.kniga.lib-i.ru - «Бесплатная электронная библиотека - онлайн материалы»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.