Урок 1
Возможно, начинающие думают, что для того чтобы создать свою первую программу на Delphi, нужно потратить много времени на изучение системы. Тем не менее, в Delphi это не сложнее простого щелчка мышкой! Итак, запустим Delphi. Для этого нужно создать ярлык на рабочем столе, если, конечно, Вам не нравится каждый раз ходить по адресу Program Files - Borland - Delphi -Bin и отыскивать файл delphi32.exe. Гораздо проще один раз найти его ярлычок в меню ПУСК - ВСЕ ПРОГРАММЫ - BORLAND DELPHI - DELPHI, перетащить его отсюда на рабочий стол и, как говорится, будет Вам счастье! Перед нами четыре окна Delphi. Вверху во вcю ширину экрана окно управления проектом и средой разработки - главное окно Delphi.
При его сворачивании сворачиваются и все остальные. Слева - Инспектор объектов. В нём задаются свойства составляющих нашу программу компонентов. И наконец, в центре одно над другим два окна Delphi, окно формы будущей программы и окно программной начинки. Прямо перед нами - окно, которое в Delphi называется Форма. Именно Форма является визуальным прообразом нашей будущей программы. Теперь посмотрите, как легко получается программа в Delphi:
Наводим мышку на зелёный треугольник-стрелку на главном окне
Смотрим - всплывает подсказка "Run (F9)"
Жмём на эту кнопку (или F9 на клавиатуре)
Получаем готовую Windows-программу!
Однако
(как подсказывают в комментариях), не
во всех версиях Delphi запуск программы
производится кнопкой F9, для некоторых
это CTRL+F9 - посмотрите сами, какую подсказку
выдает Delphi при наведении на зелёную
стрелку.
По умолчанию программа
создаётся в папке C:\Program
Files\Borland\Delphi7\Projects:
Отсюда
её можно скопировать и использовать
так, как нам нужно. Я, например, для начала
ставлю ярлык на рабочий
стол,
чтобы при тестировании проверять её
без использования Delphi.
Мы получили
программу, состоящую из одного пустого
окна. Тем не менее наша программа имеет
все атрибуты, присущие всем программам
в Windows: заголовок, системное меню (кликните
по левому краю заголовка!), кнопки
свернуть,
развернуть, закрыть,
может менять свои размеры.
Закройте
программу-Форму. Рассмотрим полезные
для нас свойства
Формы:
Надпись на заголовке - свойство Caption. Сейчас это Form1, и совпадает со свойством Name. В инспекторе объектов можно поменять их по своему усмотрению. Напишите в свойстве Caption, например, "Простейшая программа!"
Цвет - свойство Color.
Размеры - ширина и высота в пикселах, свойства Width и Height. Изменяем их мышкой, двигая края Формы, затем устанавливаем более точные значения в Инспекторе.
Положение на экране - свойства Top и Let. Это расстояния в пикселах от верхней и левой границы экрана соответственно. Если необходимое положение Формы закрывает элементы управления Delphi, просто сверните её. Но есть очень полезное
свойство Position, с помощью которого можно настроить автоматическое появление Формы в нужном месте. Разверните выпадающий список:
При значении poDesigned Форма появится в том месте, где она находилась при проектировании. Это значение по умолчанию.
При значениях poDesktopCenter и poScreenCenter Форма появится в центре рабочего стола или центре экрана. Форма может быть вызвана из другого окна-формы. Тогда при значениях
poMainFormCenter она появится в центре главного окна приложения,
poOwnerFormCenter - в центре вызывающего окна, так называемого "владельца".
Вы можете запрограммировать появление Формы в нормальном, минимизированном или максимизированном состоянии. За это отвечает
свойство WindowState - значения wsNormal, wsMinimized и wsMaximized соответственно. Не у всех окон в заголовке есть кнопки свернуть, развернуть, закрыть. Их наличием или отсутствием управляет
свойство BorderIcons. В Инспекторе слева от него маленький плюсик, открывающий признак наличия или отсутствия нужной кнопки. True - кнопка будет, False - нет. Смело экспериментируйте, но изменения будут видны только в работающей программе, а не в прототипе. А вот как вы будете закрывать Форму при biSystemMenu=False, ведь крестика закрытия не будет? Запомните сочетание ALT+F4. Это команда закрытия любых окон, включая саму Windows! Вы можете управлять также границами Формы. Для этого служит
свойство BorderStyle. При значении
bsSizeable - обычная Форма, значение по умолчанию.
bsNone - Форма вообще не будет иметь границ, включая строку заголовка.
bsSingle - Форма не может менять размеры, но может свернуться или развернуться.
Таким образом, комбинируя свойства BorderIcons и BorderStyle можно, например, получить форму с неизменными размерами и без возможности свернуться и развернуться:
Теперь займёмся сохранением нашего проекта. Так как по умолчанию Delphi сохраняет новые проекты в папке C:\Program Files\Borland\Delphi7\Projects, то если мы не будем выделять под него место сами, все файлы данного и всех будущих проектов будут свалены в кучу. Поэтому сразу в начале работы над новым проектом командой меню File -» Save All (или соответствующей кнопкой на главном окне) сохраним проект в специально для него созданную папку. Создать её можно прямо в открывшемся окошке. Проект в целом сохраняется в файле с именем Project1. Форма функционирует вместе с программой, описывающей её работу, так называемым модулем. Если модулей в проекте несколько, для каждого из них Delphi создаст отдельный файл, и предложит его сохранить под именем Unit1, Unit2 и т.д. И для файла проекта, и файлов модулей можно дать и своё, более осмысленное название. Договоримся, что каждый новый проект сразу будем сохранять, и я не буду дополнительно напоминать об этом. Теперь выполните команду File -» Close All. Попробуйте открыть файл модуля командой Open.... Модуль откроется вместе с нашей формой, мы сможем нормально работать, но кнопка запуска программы окажется неактивной. Поэтому сначала нужно открывать файл проекта. Для этого, кстати, есть специальная команда меню File -» Open Project... Ctrl F11, и соответствующая кнопка, прямо над кнопкой запуска. Теперь в окне выбора будет только один файл, файл проекта. При его открытии будет открыт и первый модуль и первая форма проекта. Для нашего проекта этого достаточно. Если в проекте несколько форм, их модули и формы открываем командой Open.... Можно открывать модули других проектов, например, для копирования кода. Теперь я предлагаю сделать следующее. Надеюсь, ваш жёсткий диск разбит хотя бы на две части, для размещения системы, и для документов. Поскольку систему приходится иногда переустанавливать, под проекты Delphi целесообразно отвести специальную папку на другом диске, например D:\Проекты Delphi\, и сохранять проекты туда, а в папку по умолчанию поставить на неё ярлык для быстрого перехода. Теперь, в случае переустановки системы, Вам не придётся дополнительно сохранять Ваши наработки.
Урок 2
В пустой форме смысла нет. Наполнить её содержанием помогут компоненты Delphi. Они располагаются на соответствующих вкладках палитры компонентов на главном окне. Все основные компоненты Delphi находятся на первых четырёх вкладках:
|
|
Их названия всплывают в виде подсказок при наведении мышки на пиктограммы. Чтобы перенести компонент на форму, нужно щёлкнуть его мышкой (при этом выбранный компонент выделяется), и затем щёлкнуть в том месте формы, где его предполагается разместить. В дальнейшем компоненты можно свободно перетаскивать по форме мышкой, "конструируя" нужный интерфейс. Если, щёлкнув по компоненту, вы захотите отказаться от его переноса на форму, щёлкните по стрелке, расположенной слева на вкладке. Выделение компонента снимется. Есть соответствующие справочники, где рассматриваются все компоненты Delphi. Но самые важные свойства компонентов Delphi и работу с ними мы рассмотрим. Рассмотрим компоненты отображения текста. Создайте новый проект (File -» New -» Application), и перенесите на форму компоненты Label, Edit, Memo и Button. Выбирая одним щелчком мышки или клавишей Tab нужный компонент, в Инспекторе Объектов мы можем получить доступ к его свойствам. Прежде всего, у визуальных компонентов есть свойства, определяющие их положение на Форме:
Ширина компонента, Width
Высота компонента, Height
Расстояние до левого края формы, Left
Расстояние до верхнего края формы, Top
Эти свойства получают значения в тот момент, когда компоненты попадают на форму. Примерно разместив на форме компоненты с помощью мышки, в Инспекторе объектов устанавливаем их точные размеры и координаты. В дальнейшем мы увидим, что их можно устанавливать и программно! За визуальное представление отвечают для компонентов:
Label и Button - свойство Caption,
Edit - свойство Text,
Memo - свойство Lines.
При "конструировании" формы в Инспекторе объектов можно придать свойствам компонентов любые значения. Случайно можно задать такие размеры или координаты, что компонент "исчезнет" - сделается невидимым или спрячется за другими компонентами. Его легко найти с помощью того же Инспектора Объектов - все компоненты, находящиеся на Форме, перечислены в его выпадающем списке. Достаточно выбрать нужный компонент, и он или его контуры (если он заслонён" другими компонентами) появятся на Форме, а в Инспекторе объектов - его свойства. Теперь "запустите" программу (зелёная стрелка или F9). Видим, что компоненты "работают". Label является надписью (меткой) на форме, Button - кнопка нажимается, Edit - строка ввода и Memo - многострочный текстовый редактор позволяют вводить текст! А теперь давайте напишем маленькую программку! Она будет по нажатию кнопки отображать на форме то, что мы введём в строке ввода. Начните новый проект (File -» New -» Application).
Расположите на форме компонент Edit (строка ввода). Свойство Text очистите.
Далее - компонент Button (кнопка). В свойстве Caption напишите, например, "показать".
Затем - компонент Label (метка). В свойстве Font для наглядности сделайте размер побольше, например 24, выберите шрифт и цвет. Свойство Caption также очистите.
Щёлкните дважды по нашей кнопке. Произошла метаморфоза! Мы очутились в окне модуля, где система Delphi создала для нас заготовку обработчика события нажатия на кнопку!
В обработчике пишите: Label1 и поставьте точку. Подождите секунду после ввода точки. Видите - выскочила подсказка!. Система Delphi предлагает нам выбрать из списка нужное свойство или метод. Нажмите "C", и строка "Caption" станет выделенной. Delphi пытается угадать, что мы хотим ввести. Дальше писать не обязятельно, достаточно нажать Enter.
В результате получим: Label1.Caption. Таким образом мы видим, что точкой разделяются в Delphi объект и его свойства. Указанием на объект служит его имя (свойство Name). Имя компонента можно посмотреть в Инспекторе Объектов, а также наведя мышку на компонент и дождавшись появления подсказки.
Далее присваиваем свойству Caption объекта Label1 значение. Знакомьтесь, оператор присваивания: := Двоеточие перед знаком равенства обязательно!!!
Получаем: Label1.Caption:= Подумайте сами, что писать дальше...
...а именно то, что мы хотим отобразить в метке - свойство Text объекта Edit1: Edit1.Text
Далее то, чем завершается любая команда - оператор ";". Это именно оператор, хотя и не выполняющий никаких действий, и его иногда применяют именно в этом качестве.
Вот что у нас получилось: Label1.Caption := Edit1.Text; Кому лень, просто скопируйте отсюда и вставляйте между begin и end. Ну всё, сохраняем и жмём F9.
Урок 3
События Delphi
Операционная система Windows - многозадачная, т.е. несколько программ в ней могут функционировать одновременно. Когда, например, мы щёлкаем по кнопке в окне нашей программы, система Windows определяет, что произошло событие именно в нашей программе, и посылает ей сообщение об этом. Наша программа должна соответствующим образом отреагировать на него. Для этого мы, как программисты, должны написать код-обработчик этого события. Таким образом, структура программы для Windows представляет собой набор подпрограмм, каждая из которых ответственна за обработку конкретного события и вызывается только при его возникновении. Удобство Delphi состоит в том, что мы избавлены от необходимости получать сообщения от Windows сами, Delphi это делает за нас. Каждый компонент имеет впечатляющий набор событий, на которые он может реагировать. Программист сам определяет, какие события в программе требуется обрабатывать.
|
Откройте наш проект из предыдущего урока. Щелкните на компоненте Edit1. Он "появится" в Инспекторе объектов. Посмотрите: в Инспекторе объектов две вкладки: Properties (свойства) и Events (события). Перейдите на вкладку Events. Чтобы создать обработчик нужного события, нужно дважды кликнуть по нему мышкой. А если раскрыть выпадающий список, в нём будут находиться уже готовые обработчики, которые могут подходить для этого компонента. Таким образом, один обработчик может вызываться для обработки событий нескольких компонентов. |
Изменим нашу программу так, чтобы текст на форме появлялся прямо в момент его ввода. В момент ввода у Edit1 меняется свойство Text - в нём появляется новая буква! Значит, воспользуемся событием onChange (change - изменение (англ.)), которое и происходит в этот момент. Итак:
|
Теперь рассмотрим событие onClick. Как вы догадываетесь, это событие возникает при щелчке мышкой на компоненте. Воспользуемся им, чтобы очищать строку ввода от уже введённых символов. Вы сами уже должны сообразить, что сделать. В обработчике нужно присвоить свойству Text значение пустой строки. Строка в Delphi образуется заключением текста в одинарные кавычки (находятся на кнопке Э): 'Так в Delphi образуется строка' Значит, пустая строка - это кавычки без текста: ''. Не должно быть даже пробела, иначе он окажется в строке ввода: Edit1.Text:=''; Есть другой способ, воспользоваться специально предназначенным для этого методом компонента Edit, который так и называется Clear (очистка англ.): Edit1.Clear; Но подумайте о пользователе, который будет работать с вашей программой. Ему должно быть удобно. Если при вводе текста он захочет что-то исправить, и щёлкнет мышкой в том месте текста, где нужно внести изменение?! И всё сотрётся! Поэтому лучше использовать событие onEnter, которое происходит, когда вы "входите" в него и компонент получает фокус ввода, или использовать для очистки специальную кнопку и её событие onClick. Конечно, у каждого компонента свой набор событий. Мы познакомились с тремя из них:
|
Другие важные события, которые есть почти у каждого визуального компонента:
В начале работы любой программы происходит очень важное событие событие нашего основного компонента - Формы, onCreate. Оно происходит перед появлением Формы на экране. Это событие используется для задания свойств тех элементов программы, которые нуждаются в настройке, например, размеры и положение Формы на экране. Если вы захотите сделать невидимую программу, можно приравнять нулю ширину Width и высоту Height Формы. На этапе проектирования сделать этого нельзя, т.к. это помешает работе, поэтому делаем это по событию onCreate: Form1.Width := 0; Form1.Height := 0; Дополнительно нужно убрать и заголовок Формы, выбрав в Инспекторе Объектов параметр BorderStyle равным None. Теперь Форма на экране не появится. Единственным визуальным признаком останется появление её "значка" на панели задач. В дальнейшем я расскажу, как избавиться и от него. |
Урок 4
Переменные, константы и их типы
Данные в компьютере можно рассматривать как ячейки памяти, имеющие свои имена (идентификаторы). Все данные в программе на языке Delphi должны быть описаны до их первого использования. И компилятор следит, чтобы в программе они использовались в соответствии с этим описанием, что позволяет избежать ошибок. Любая величина в Delphi может быть постоянной или переменной. Её имя (идентификатор) может состоять из комбинации латинских букв, цифр и знака подчёркивания, и начинаться не с цифры. При этом регистр символов значения не имеет. Место описания данных в программе - вне логических блоков begin / end. В модуле перед ключевым словом implementation есть блок описания: var Form1: TForm1; Именно здесь, начиная со следующей строки, удобно объявлять глобальные переменные и константы. Как видим, одна (Form1) уже есть! Команда объявления переменных в языке Delphi: var имя_переменной : тип_переменной ; Слово var - ключевое. Именем может быть любой идентификатор, если он не был описан ранее и не является одним из ключевых или зарезервированных слов языка Delphi. Если нужно описать несколько переменных одного типа, то их перечисляют, отделяя запятой: var A, B, C : Integer; Если несколько описаний следуют друг за другом, то ключевое слово var повторно можно не указывать: var A, B : Integer; C, D : String; Постоянную величину иначе называют константой. Конечно, в программе можно использовать числа и строки непосредственно: 3.1415 или 'Это значение числа пи', но иногда удобнее присвоить их идентификатору. Описание констант аналогично описанию переменных, но используется ключевое слово const, за именем идентификатора следует тип, затем знак равенства и его значение. Причём тип константы допускается не указывать: const pi=3.1415 ; ZnakPi : String = 'Это значение числа пи'; К слову, константа Pi встроенная в Delphi, то есть для того чтобы использовать в Delphi число 3,1415... в расчётах, нужно просто присвоить встроенную константу Pi переменной типа Real или просто использовать непосредственно в выражениях. Теперь пришло время узнать о типах данных, используемых в Delphi. Прежде всего это строки и числа. Строкой называется последовательность символов, заключённая в одиночные кавычки:
'это текстовая строка'
Если текст должен содержать сам символ кавычки, то его надо повторить дважды:
'это '' - символ одиночной кавычки'
Строка может быть и пустой, не содержащей символов. Тогда она состоит из двух идущих друг за другом без пробела кавычек. Естественно, строка может состоять и только из одних пробелов. Самый популярный строковый тип - String. Строка типа String может содержать переменное количество символов объёмом до 2 Гбайт. Если нужно ограничить размер строки фиксированным значением, то после ключевого слова String в квадратных скобках указывается число, определяющее количество символов в строке: String[50]. Более полно работа со строками Delphi описывается далее. Одиночный символ имеет тип Char и записывается в виде знака в одиночных кавычках: 'a'. Есть символы, которые на экране отобразить невозможно, например, символ конца строки (равен #13), символ переноса строки (равен #10). Такие символы записываются в виде их числового кода (в кодировке ANSI), перед которым стоит знак #. Например, #0. Наконец, существуют так называемые нуль-терминированные строки. Отсчёт символов в таких строках начинается с нуля, а заканчивается символом с кодом 0 (#0). Такие строки имеют тип PChar. Числа бывают целые и дробные. В следующей таблице перечислены стандартные типы целых чисел и соответствующие им дипазоны допустимых значений.
|
Наиболее удобным для использования в программах является тип Delphi Integer. Другие целые типы используются для уменьшения места, занимаемого данными в памяти компьютера. |
Дробные числа имеют дробную часть, отделяемую десятичной точкой. Допускается использование символа e (или E), за которым следует число, указывающее, что левую часть нужно умножить на 10 в соответствующей степени: 5e25 - пять умножить на десять в двадцать пятой степени. Ниже приведены стандартные типы дробных чисел и соответствующие им диапазоны допустимых значений. Для большинства типов указан диапазон положительных значений, однако допустимым является аналогичный диапазон отрицательных значений, а также число 0.
|
Наиболее удобным для использования в программах является тип Delphi Real. Ему эквивилентен тип Double, но в будущем это может быть изменено. Вычисления с дробными числами выполняются приближённо, за исключением типа Currency (финансовый), который предназначен для минимизации ошибок округления в бухгалтерских расчётах. |
Следующим типом данных является логический Boolean, состоящий всего из двух значений: True (Истина) и False (Ложь). При этом True > False. Теперь, используя компоненты, их свойства и события, вводя собственные переменные, можно конструировать программы, содержащие вычисления. Осталось узнать, как вычисленное значение вывести на экран. Про консольные программы я здесь не говорю! А в нормальных оконных Windows-приложениях это значение нужно поместить в какой-нибудь компонент, имеющий свойства Text или Caption. Это, например, такие компоненты как Label и Edit, да и сама Форма имеет свойство Caption, куда тоже можно выводить информацию. Однако, в Delphi информацию перед выводом, как правило, необходимо преобразовывать. Так как присвоение возможно только между переменными одного типа, то такая программа (не пытайтесь её исполнять): var A, B, C: Integer ; begin A := 5 ; B := 10 ; C := A+B ; Label1.Caption := C ; end ; вызовет ошибку, так как свойство Caption имеет текстовый тип String, а использованные переменные - цифровой тип Integer. Значит, нужно преобразовать значение переменной C в текстовый тип. Для этого есть встроенная функция IntToStr. Строка в нашей "программе", вызывавшая ошибку, должна выглядеть так: Label1.Caption := IntToStr(C) ; Такая программа, кроме показа числа 15, ни на что не способна. Мы должны научиться вводить в программу другие числа. Используем компоненты Edit. Введённые числа будут содержаться в свойстве Text этих компонентов. Расположим на форме два компонента Edit, один компонент Label и кнопку Button, по нажатию на которую и будем проводить вычисления. В компоненты Edit1 и Edit2 будем вводить числа для суммирования. Чтобы переместиться в редактор кода, щёлкнем дважды по нашей кнопке Button1. Мы попадём прямо в сформированную для нас средой Delphi заготовку обработчика нажатия на кнопку, непосредственно между операторами begin и end. Напишем такой простой код: procedure TForm1.Button1Click(Sender: TObject); var A, B, C: Integer;//Не забудьте описание переменных begin //Начало кода: A := Edit1.Text; B := Edit2.Text; C := A+B; Label1.Caption := IntToStr(C); //Конец кода end ; При попытке исполнить этот код Delphi покажет ошибки по аналогичной причине - переменные A и B имеют цифровой тип Integer, а свойство Text - текстовый тип String. Исправить ошибки поможет встроенная функция StrToInt, выполняющая обратное преобразование - текст в целое число. Операторы присвоения переменным A и B должны выглядеть так: A := StrToInt(Edit1.Text); B := StrToInt(Edit2.Text); В данном случае переменные A, B, C использовались для наглядности. Можно обойтись одной строчкой: Label1.Caption:=IntToStr(StrToInt(Edit1.Text)+StrToInt(Edit2.Text)); Аналогично, имеются функции и для преобразования в строку и обратно действительных чисел c плавающей (Floating англ.) запятой, имеющих тип Real. Для преобразования в строку - FloatToStr, обратно - StrToFloat. Часто результаты вычислений, имеющие тип Delphi Real, имеют после запятой длинный "хвост" цифр. При выводе такой переменной в текстовом виде необходимо ограничить количество цифр после запятой. Как это можно сделать, описывается также в Уроке Delphi Работа со строками Delphi.
Урок 5
Собственные и структурные типы данных
При создании любой серьёзной программы не обойтись без дополнительных, более сложных, чем числа и строки, типов данных. В Delphi программист может для своих целей конструировать собственные типы данных. Чтобы ввести в программу (описать) новый тип данных, применяется оператор с ключевым словом type: type название_типа = описание_типа; Перечислимый тип - это тип данных, диапазоном значений которого является просто набор идентификаторов. Это может применяться в тех случаях, когда нужно описать тип данных, значения которого нагляднее представить не числами, а словами. Перечислимый тип записывается взятой в круглые скобки последовательностью идентификаторов - значений этого типа, перечисляемых через запятую. При этом, первые элементы типа считаются младшими по сравнению с идущими следом. Например, тип, описывающий названия футбольных команд, можно сформировать так: type FootballTeam = (Spartak, Dinamo, CSKA, Torpedo, Lokomotiv); var MyTeam: FootballTeam; begin MyTeam:=Spartak; end; Вообще, под перечислимыми типами понимают все типы, для которых можно определить последовательность значений и их старшинство. К ним относятся:
все целочисленные типы, для которых всегда можно указать число, следующее за числом N;
символьные типы (Char): за символом 'a' всегда следует 'b', за '0' следует '1', и так далее;
логические типы - тип Boolean также представляет собой перечислимый тип: type Boolean = (false, true);
Структурные типы данных используются практически в любой программе. Это такие типы, как
массивы
записи
множества
Массив - это структура данных, доступ к элементам которой осуществляется по номеру (или индексу). Все элементы массива имеют одинаковый тип. Описание массива имеет вид: type имя_типа_массива = array [диапазон] of тип_элемента; Диапазон определяет нижнюю и верхнюю границы массива и, следовательно, количество элементов в нём. При обращении к массиву индекс должен лежать в пределах этого диапазона. Массив из ста элементов целого типа описывается так: type TMyArray = array [1 .. 100] of Integer; Теперь можно описать переменные типа TMyArray: var A, B: TMyArray; Вместо присвоения типа можно явно описать переменные как массивы: var A, B : array [1..100] of Integer; Для доступа к элементу массива нужно указать имя массива и индекс элемента в квадратных скобках. В качестве индекса может выступать число, идентификатор или выражение, значение которых должно укладываться в диапазон, заданный при описании массива: var N: Integer; begin N := 65; A[5] := 101; A[N] := 165; A[N+3] := 200; B := A; end; Иногда требуется узнать верхнюю или нижнюю границу массива. Для этого служат встроенные функции: High() - вернёт число, являющееся верхней границей массива; Low() - вернёт число, являющееся нижней границей массива. В скобки нужно подставить массив, границы которого требуется узнать. Выражение B := A означает, что каждый элемент массива B будет равен элементу с таким же индексом массива A. Такое присвоение возможно только если оба массива объявлены через некий поименованный тип, или перечислены в одном списке. И в случае: var A: array[1..100] of String; B: array[1..100] of String; его использовать невозможно (но возможно поэлементное присвоение B[1] := A[2]; и т.д.). Массивы могут иметь несколько измерений, перечисляемых через запятую. Например, таблицу из четырёх столбцов и трёх строк:
|
|
можно описать в виде массива с двумя измерениями: type MyTable = array[1..4, 1..3] of Integer; var X : MyTable; Y : Integer; begin Y:=X[3, 2]; end; Теперь в результате операции присвоения Y будет равен 7. Многомерный, например, двумерный массив можно описать как массив массивов: type TMyArray = array [1 .. 4] of array [1 .. 3] of Integer; Результат будет аналогичен предыдущему примеру. Каждое измерение многомерного массива может иметь свой собственный тип, не обязательно целый. Кроме вышеописанных, так называемых статических массивов, у которых количество элементов неизменно, в Delphi можно использовать динамические массивы, количество элементов в которых допускается изменять в зависимости от требований программы. Это позволяет экономить ресурсы компьютера, хотя работа с такими массивами происходит гораздо медленнее. Описываются динамические массивы аналогично статическим, но без указания диапазона индексов: type TDinArray = array of Integer; var A : TDinArray; После создания в динамическом массиве нет ни одного элемента. Необходимый размер задаётся в программе специальной процедурой SetLength. Массив из ста элементов: begin SetLength(A, 100); end; Нижняя граница динамического массива всегда равна нулю. Поэтому индекс массива A может изменяться от 0 до 99. Многомерные динамические массивы описываются именно как массивы массивов. Например, двумерный: type T3DinArray = array of array of Integer; var A : T3DinArray; В программе сначала задаётся размер по первому измерению (количество столбцов):
SetLength(A, 3); Затем задаётся размер второго измерения для каждого из трёх столбцов, например: SetLength(A[0], 3); SetLength(A[1], 2); SetLength(A[2], 1); |
Таким образом создаётся треугольная матрица: |
A00 A10 A20 A01 A12 A02 |
Чтобы освободить память, выделенную динамическому массиву, нужно массиву как целому присвоить значение nil: A:=nil; Ключевое слово nil в Delphi означает отсутствие значения. Записи очень важный и удобный инструмент. Даже не применяя специальные технологии, с его помощью можно создавать собственные базы данных. Записи - это структура данных, каждый элемент которой имеет собственное имя и тип данных. Элемент записи иначе называют поле. Описание записи имеет вид: type имя_типа_записи = record название_поля : тип_поля ; . . . название_поля : тип_поля ; end; Названия полей, имеющих одинаковый тип, можно, как и в случае описания переменных, указывать в одну строку через запятую. Для обращения к полю записи сначала указывают имя записи, затем точку, затем имя поля. Например, данные о персонале предприятия могут быть организованы таким типом записи: type TPers = record Fam, Name, Par : String; Year : Integer; Dep : String; end; var Pers : TPers; begin Pers.Fam:='Иванов'; Pers.Name:='Иван'; Pers.Par:='Иванович'; Pers.Year:=1966; Pers.Dep:='Цех №1'; end; Теперь осталось записать эти данные в файл, предварительно объявив и его тип как TPers, и база данных готова. С файлом в Delphi также ассоциируется переменная, называемая файловой переменной, которая описывается так: VFile : file of тип_файла; В качестве типа может использоваться любой ограниченный тип Delphi. При этом не допускается тип String, так как он допускает переменный размер до 2 ГБайт. Его необходимо ограничивать: String[N], где N - количество символов. Тип TPers из предыдущего примера должен быть описан, например, так: type TPers = record Fam, Name, Par : String[20]; Year : Integer; Dep : String[10]; end; Теперь переменная такого типа занимает строго определённое место в памяти, и может быть записана в файл. Как это сделать, рассказывается во 2-й части Урока №7. Множество - это группа элементов, объединённая под одним именем, и с которой можно сравнивать другие величины, чтобы определить, принадлежат ли они этому множеству. Количество элементов в одном множестве не может превышать 256. Множество описывается так: type имя_множества = set of диапазон_значений_множества ; В качестве диапазона может указываться любой тип, количество элементов в котором не больше 256. Например: type TMySet = set of 0 .. 255; type TMySet = set of Byte; Конкретные значения множества задаются в программе с помощью перечисления элементов, заключённых в квадратные скобки. Допускается использовать и диапазоны: var MySet : TMySet; begin MySet:=[1, 3 .. 7, 9]; end; Чтобы проверить, является ли некое значение элементом множества, применяется оператор in в сочетании с условным оператором: var Key : Char; Str : String; begin if Key in ['0' .. '9', '+', '-'] then Str:='Math'; end; Чтобы добавить элемент во множество, используется операция сложения, удалить - вычитания: var Digit: set of Char=['1'..'9']; var Math: Set of Char; begin Math:=Digit+['+', '-', DecimalSeparator*]; end;
Урок 6
Выражения и операторы
В программах Delphi применяются
математические выражения
логические выражения
выражения со строками
ну и другие.
Математические выражения
В математических выражениях используются операции присваивания :=, сложения +, вычитания -, умножения *, деления /, целочисленного деления div, остатка от деления mod. При использовании этих операций важен приоритет их выполнения, так как в программировании на языке Delphi, как и в обычной математике, выражения выполняются не в порядке следования, а с учётом приоритета. У операций умножения и деления более высокий приоритет, чем у операций сложения и вычитания. То есть, результат выражения X:=1+2*3-4/5; будет равен не 1, как в случае последовательного выполнения, а 6.2 . Если же мы хотим получить именно последовательное выполнение, то необходимо применять скобки (), обособляющие те операции, которые необходимо выполнить первыми. Скобки могут быть вложены друг в друга неограниченное число раз: X:=((1+2)*3-4)/5; Вот теперь X будет равен 1. Помимо четырёх математических действий в Delphi доступно множество математических функций, таких, например, как тигонометрические, логарифмические, и т.д. Они становятся доступны в программе после добавления в секцию Interface uses модуля Math. Их описание также можно найти в модуле Math.pas (можно найти воспользовавшись поиском Windows). Многие из них можно реализовать и самому, но встроенные функции наверняка будут работать быстрее и лучше, т.к. написаны на языке ассемблера.
Логические выражения
Логические выражения выполняются над операндами логического типа, то есть имеющими тип Boolean Delphi. Они применяются в основном в условных операторах.
Операторы Delphi
Для создания приложений, реализующих сложную алгоритмическую логику, нужны средства управления ходом работы программы: изменения порядка выполнения операторов в зависимости от различных условий, и эффективной организации работы часто повторяющихся фрагментов. Математически доказано, что любой алгоритм можно закодировать с помощью
оператора присваивания
условного оператора
оператора цикла
С оператором присваивания ":=" мы уже знакомились в уроке Delphi 2. Он работает следующим образом. Переменная, стоящая в левой части оператора, становится равной той величине, которая находится справа. Типы этих величин должны совпадать. В выражении, стоящем справа, также может использоваться переменная, стоящая слева. С математической точки зрения это неправильно, но в программировании это означает, что из ячейки памяти берётся исходное значение, производятся вычисления, и результат записывается в эту же ячейку памяти, затирая прежнее значение. Пример: var A, B : Integer; begin A:=3; B:=4; A:=A*A+B*B; end; В начале фрагмента переменная A равна 3, а в конце -25. Условный оператор позволяет изменить порядок выполнения операторов в зависимости от выполнения некоторого условия. Вот как он записывается: if условие then действие else альтернатива ; Слова if (если), then (тогда), else (иначе) - зарезервированные. Действие и else альтернатива - это любые операторы Delphi, или несколько операторов, заключённых в логические скобки begin/end, или вызов подпрограммы. Если условие истинно, то выполняется действие, если ложно, то выполняется альтернатива. Условие представляет собой логическое выражение. В нём сравниваются значения выражений (в том числе также и логических), вызов функций, возвращающих значения типа Boolean, и комбинирование этих значений с помощью логических операций:
Знак операции |
Название операции |
Логические операции могут комбинироваться с помощью связок: and (логическое И) or (логическое ИЛИ) xor (исключающее ИЛИ) Для некоторых типов данных есть дополнительные операции. Например, для множеств - оператор in, которая проверяет, входит ли некоторое значение в множество. Например: X := [2, 4, 5, 7, 8, 10] ; Выражение 2 in X истинно (имеет значение true); Выражение 6 in X ложно (имеет значение false); |
= |
Равно |
|
<> |
Не равно |
|
> |
Больше |
|
< |
Меньше |
|
>= |
Больше или равно |
|
<= |
Меньше или равно |
|
not |
Логическое Не - отрицание |
Результат выполнения операции логического И равен true, если оба операнда равны true. Результат выполнения операции логического ИЛИ равен true, если хотя бы один из операндов равен true. Результат выполнения операции исключающего ИЛИ равен true, если операнды не равны друг другу. Операторы цикла позволяют организовать многократное повторение одной и той же последовательности действий. В Delphi имеются три оператора, позволяющих это сделать:
"простой" оператор цикла
условный оператор цикла
условный оператор повторения
Простой оператор цикла применяется, когда известно количество повторений цикла. Он записывается так: for счётчик := выражение-1 to выражение-2 do действие ; Счётчик - это переменная, которая должна быть объявлена перед логическим блоком, в котором оператор цикла расположен, и её тип должен относиться к одному из перечислимых типов, обычно Integer. Выражение-1 и выражение-2 могут быть как константой или идентификатором, так и вызовом функции. Действие - один или несколько операторов Delphi. Если это группа операторов, то они должны быть заключены в логические скобки begin/end. В начале работы оператора переменная-счётчик получает значение выражения-1. Если при этом значение счётчика окажется меньше или равно значению выражения-2, то выполняются операторы, входящие в действие. Это и есть один цикл. Затем переменная-счётчик принимает значение, следующее за текущим, и начинается новый цикл, то есть сравнение счётчика и выражения-2, выполнение действия, и так далее, до тех пор, пока значение переменной-счётчика не превысит значение выражения-2. Возможна работа оператора цикла, при котором переменная-счётчик будет не увеличиваться, а уменьшаться. В этом случае ключевое слово to заменяется на downto: for счётчик := выражение-1 downto выражение-2 do действие ; Соответственно, выражение-1 должно быть больше или равно выражению-2. Условный оператор цикла удобно использовать в том случае, когда количество повторений заранее не известно: while условие do тело цикла ; Этот цикл будет выполняться до тех пор, пока истинно условие (логическое выражение, возвращающее значение типа Boolean). При этом если это выражение сразу равно false, тело цикла не будет выполнено ни разу. Нужно очень внимательно следить за написанием условия и контролем завершения цикла, так как в результате ошибки цикл while будет повторяться бесконечное количество раз, что приведёт к "зацикливанию" и "зависанию" программы. Условный оператор повторения сначала выполняет тело цикла, а затем уже проверяет выполнение условия: repeat тело цикла until условие ; Таким образом, этот вариант цикла гарантирует, что тело цикла будет выполнен по крайней мере один раз. И будет выполняться до тех пор, пока условие не станет истинным (т.е. true). Стоит отметить, что это единственный оператор Delphi, в котором тело цикла не требуется заключать в логические скобки begin/end. Начало и конец тела цикла определяются по ключевым словам repeat и until. Вместе с операторами цикла используются специальные команды:
команда прерывания цикла
команда продолжения цикла
Команда прерывания цикла применяется, если в процессе выполнения операторов тела цикла выясняется необходимость его завершения. Вот эта команда: Break ; При её выполнении управление передаётся на первый оператор, следующий за оператором цикла. Команда продолжения цикла позволяет немедленно продолжить выполнение цикла, пропустив все оставшиеся операторы в теле цикла, то есть начать следующую итерацию. Вот эта команда: Continue ; Справедливости ради стоит рассказать об ещё одном операторе, позволяющем изменить последовательность выполнения программы. Это оператор перехода: goto метка ; В качестве метки может использоваться любой допустимый идентификатор или число в диапазоне от 0 до 9999. Метку предварительно необходимо объявить в разделе описания переменных, но с помощью не ключевого слова var, а ключевого слова label: label меткa ; или label список меток ; Переходить можно как вниз, так и вверх по программе. Двоеточие отделяет метку от оператора, на который производится переход. Пример использования оператора перехода: var X, Y: Integer; label A, B; begin A: X:=5 ; . . . операторы программы goto B; . . . B: Y:=25; goto A; end; Из этого примера видно, что оператор end ; завершающий программу, никогда не будет выполнен, то есть программа зациклится. Именно поэтому, вообще, использование оператора перехода является плохим стилем программирования, и без его использования вполне можно обойтись использованием условных операторов и операторов цикла. Единственный случай, когда использование оператора goto может быть оправдано - это выход из нескольких вложенных циклов, что иначе требует применения нескольких операторов Break.