Как работать в Delphi: конкретные уроки

Урок Delphi 1 .Windows - программа нажатием одной кнопки!

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

Итак, запустим Delphi. Для этого нужно создать ярлык на рабочем столе, если, конечно, Вам не нравится каждый раз ходить по адресу Program Files - Borland - Delphi -Bin и отыскивать файл delphi32.exe. Гораздо проще один раз найти его ярлычок в меню ПУСК - ВСЕ ПРОГРАММЫ - BORLAND DELPHI - DELPHI, перетащить его отсюда на рабочий стол и, как говорится, будет Вам счастье!
Перед нами четыре окна Delphi. Вверху во вcю ширину экрана окно управления проектом и средой разработки - главное окно Delphi.

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

Видео на тему: #1 Программирование в Delphi. "Hello World" на Delphi

Теперь посмотрите, как легко получается программа в Delphi:

1. Наводим мышку на зелёный треугольник-стрелку на главном окне
2. Смотрим - всплывает подсказка "Run (F9)"
3. Жмём на эту кнопку (или F9 на клавиатуре)
4. Получаем готовую Windows-программу!

   Однако (как подсказывают в комментариях), не во всех версиях Delphi запуск программы производится кнопкой F9, для некоторых это CTRL+F9 - посмотрите сами, какую подсказку выдает Delphi при наведении на зелёную стрелку.
По умолчанию программа создаётся в папке C:\Program Files\Borland\Delphi7\Projects:

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

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

   Закройте программу-Форму. Рассмотрим полезные для нас свойства Формы:

1. 1. Надпись на заголовке - свойство Caption. Сейчас это Form1, и совпадает со свойством Name. В инспекторе объектов можно поменять их по своему усмотрению. Напишите в свойстве Caption, например, "Простейшая программа!"
   2. Цвет - свойство Color.
   3. Размеры - ширина и высота в пикселях, свойства Width и Height. Изменяем их мышкой, двигая края Формы, затем устанавливаем более точные значения в Инспекторе.
   4. Положение на экране - свойства Top и Left. Это расстояния в пикселях от верхней и левой границы экрана соответственно. Если необходимое положение Формы закрывает элементы управления Delphi, просто сверните её. Но есть очень полезное
   5. свойство Position, с помощью которого можно настроить автоматическое появление Формы в нужном месте. Разверните выпадающий список:
      • • При значении poDesigned Форма появится в том месте, где она находилась при проектировании. Это значение по умолчанию.
        • При значениях poDesktopCenter и poScreenCenter Форма появится в центре рабочего стола или центре экрана.
         Форма может быть вызвана из другого окна-формы. Тогда при значениях
      • poMainFormCenter она появится в центре главного окна приложения,
      • poOwnerFormCenter - в центре вызывающего окна, так называемого "владельца".
      Вы можете запрограммировать появление Формы в 

нормальном, минимизированном или максимизированном состоянии. За это отвечает.

1. 6. свойство WindowState - значения wsNormal, wsMinimized и wsMaximized соответственно. 
   1. Не у всех окон в заголовке есть кнопки
   свернуть, развернуть, закрыть.

Их наличием или отсутствием управляет

7. свойство BorderIcons. В Инспекторе слева от него маленький плюсик, открывающий признак наличия или отсутствия нужной кнопки. True - кнопка будет, False - нет. Смело экспериментируйте, но изменения будут видны только в работающей программе, а не в прототипе. А вот как вы будете закрывать Форму при biSystemMenu=False, ведь крестика закрытия не будет? Запомните сочетание ALT+F4. Это команда закрытия любых окон, включая саму Windows!

   Вы можете управлять также границами Формы. Для этого служит

1. 8. свойство

BorderStyle

. При значении

1. •  
   • 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\, и сохранять проекты туда, а в папку по умолчанию поставить на неё ярлык для быстрого перехода. Теперь, в случае переустановки системы, Вам не придётся дополнительно сохранять Ваши наработки.

Урок Delphi 2. Компоненты Delphi - основа визуального проектирования!

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

• Standard,
• Additional,
• Win32,
• System.

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

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

Есть соответствующие справочники, где рассматриваются все компоненты 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 очистите.

1. Далее - компонент Button (кнопка). В свойстве Caption напишите, например, "показать".
2. Затем - компонент Label (метка). В свойстве Font для наглядности сделайте размер побольше, например 24, выберите шрифт и цвет. Свойство Caption также очистите.
3. Щёлкните дважды по нашей кнопке. Произошла метаморфоза! Мы очутились в окне модуля, где система Delphi создала для нас заготовку обработчика события нажатия на кнопку!
4. В обработчике пишите: Label1 и поставьте точку. Подождите секунду после ввода точки. Видите - выскочила подсказка!. Система Delphi предлагает нам выбрать из списка нужное свойство или метод. Нажмите "C", и строка "Caption" станет выделенной. Delphi пытается угадать, что мы хотим ввести. Дальше писать не обязятельно, достаточно нажать Enter.
5. В результате получим: Label1.Caption. Таким образом мы видим, что точкой разделяются в Delphi объект и его свойства. Указанием на объект служит его имя (свойство Name). Имя компонента можно посмотреть в Инспекторе Объектов, а также наведя мышку на компонент и дождавшись появления подсказки.
6. Далее присваиваем свойству Caption объекта Label1 значение. Знакомьтесь, оператор присваивания:
      :=
   Двоеточие перед знаком равенства обязательно!!!
7. Получаем:
     Label1.Caption:=
   Подумайте сами, что писать дальше...
8. ...а именно то, что мы хотим отобразить в метке - свойство Text объекта Edit1: Edit1.Text
9. Далее то, чем завершается любая команда - оператор ";". Это именно оператор, хотя и не выполняющий никаких действий, и его иногда применяют именно в этом качестве.

   Вот что у нас получилось:

Label1.Caption := Edit1.Text;

Кому лень, просто скопируйте отсюда и вставляйте между begin и end. Ну всё, сохраняем и жмём F9.

   В дальнейшем программы будут куда сложнее. Что делать, если в результате ошибки в программе она зависнет? Естественно, можно воспользоваться комбинацией Ctrl+Alt+Del, но проще, нажав OK в окне предупреждения об ошибке, выполнить команду меню главного окна Delphi Run -» Program Reset или Ctrl+F2!

Урок Delphi 3. События Delphi

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

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

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

   Изменим нашу программу так, чтобы текст на форме появлялся прямо в момент его ввода. В момент ввода у Edit1 меняется свойство Text - в нём появляется новая буква! Значит, воспользуемся событием onChange (change - изменение (англ.)), которое и происходит в этот момент. Итак:

   Теперь рассмотрим событие onClick. Как вы догадываетесь, это событие возникает при щелчке мышкой на компоненте. Воспользуемся им, чтобы очищать строку ввода от уже введённых символов. Вы сами уже должны сообразить, что сделать. В обработчике нужно присвоить свойству Text значение пустой строки. Строка в Delphi образуется заключением текста в одинарные кавычки (находятся на кнопке Э):
    'Так в Delphi образуется строка'
Значит, пустая строка - это кавычки без текста: ''. Не должно быть даже пробела, иначе он окажется в строке ввода:

   Edit1.Text:='';

Есть другой способ, воспользоваться специально предназначенным для этого методом компонента Edit, который так и называется Clear (очистка англ.):

   Edit1.Clear;

   Но подумайте о пользователе, который будет работать с вашей программой. Ему должно быть удобно. Если при вводе текста он захочет что-то исправить, и щёлкнет мышкой в том месте текста, где нужно внести изменение?! И всё сотрётся! Поэтому лучше использовать событие onEnter, которое происходит, когда вы "входите" в него и компонент получает фокус ввода, или использовать для очистки специальную кнопку и её событие onClick.
   Конечно, у каждого компонента свой набор событий. Мы познакомились с тремя из них:

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

• onExit - возникает, когда компонент теряет фокус ввода;
• onDblClick - возникает при двойном щелчке мышкой по компоненту;
• onKeyDown - когда при нажатии на кнопку на клавиатуре она оказалась в нижнем положении;
• onKeyUp - когда при отпускании клавиатурной кнопки она оказалась в верхнем положении;
• onKeyPress - возникает при нажатии на клавиатурную кнопку. От событий onKeyDown и onKeyUp оно отличается типом используемого параметра Key ;
• onMouseDown - когда при нажатии кнопки мышки она оказалась в нижнем положении;
• onMouseUp - когда при отпускании кнопки мышки она оказалась в верхнем положении;
• onMouseMove - возникает при перемещении указателя мышки над компонентом.

   В начале работы любой программы происходит очень важное событие событие нашего основного компонента - Формы, onCreate. Оно происходит перед появлением Формы на экране.

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

Если вы захотите сделать невидимую программу, можно приравнять нулю ширину Width и высоту Height Формы. На этапе проектирования сделать этого нельзя, т.к. это помешает работе, поэтому делаем это по событию onCreate:

   Form1.Width := 0;
   Form1.Height := 0;

Дополнительно нужно убрать и заголовок Формы, выбрав в Инспекторе Объектов параметр BorderStyle равным None. Теперь Форма на экране не появится. Единственным визуальным признаком останется появление её "значка" на панели задач. В дальнейшем я расскажу, как избавиться и от него.

Урок Delphi 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.

Урок 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;

В программе сначала задаётся размер по первому измерению (количество столбцов):

Чтобы освободить память, выделенную динамическому массиву, нужно массиву как целому присвоить значение 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;

^*Примечание: DecimalSeparator - встроенная в Delphi константа типа Char, имеющая значение символа-разделителя целой и дробной частей, который может быть равен точке ('.') либо запятой (','), в зависимости от текущих настроек Windows.

Урок Delphi 6. Выражения и операторы Delphi

Выражения Delphi

   В программах 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). Многие из них можно реализовать и самому, но встроенные функции наверняка будут работать быстрее и лучше, так далее. написаны на языке ассемблера.

Операторы 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, и комбинирование этих значений с помощью логических операций:

Результат выполнения операции логического И равен 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.

Урок Delphi 7. Работа с файлами в Delphi

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

   Для "лирического" вступления нужно упомянуть компоненты Delphi, которые умеют работать с файлами. Они читают и сохраняют своё содержимое, строки типа String, в файл текстового формата. Это компоненты ListBox, ComboBox и Memo, расположенные на первой же вкладке палитры компонентов.

   Каждая строка компонентов ListBox и ComboBox является объектом Items[i], а Memo - Lines[i], где i - номер строки, который отсчитывается от нуля. Добавление строк в компоненты выполняется методами Add и Insert:

begin
   Memo1.Lines.Add('Первая строка');
   ComboBox1.Items.Add('Первая строка');
   ComboBox1.Items.Add('Вторая строка');
   ListBox1.Items.Add('Первая строка');
   ListBox1.Items.Add('Вторая строка');
  end ;

Метод Add добавляет новую строку в конец. Метод Insert имеет дополнительный параметр, указывающий, после какой строки разместить новую строку. Доступ к строкам осуществляется так:

   ComboBox1.Items[0] := 'Первая строка изменилась' ;
   ListBox1.Items[1] := 'Вторая строка изменилась' ;

У компонента ComboBox дополнительно есть свойство Text, где (как и у компонента Edit) находится вводимый текст:

   ComboBox1.Text := ' Вводимый текст ';

На выделенную в данный момент строку компонента ComboBox указывает свойство ItemIndex типа Integer, то есть это номер выделенной строки. Следовательно, получить саму выделенную строку компонента ComboBox можно следующей конструкцией:

   S:=ComboBox1.Items[ComboBox1.ItemIndex];

или, пользуясь оператором присоединения

   With ComboBox1 do
    S:=Items[ItemIndex];

Вот как по нажатию клавиши Enter можно заносить в этот компонент вводимую в строку информацию и удалять нажатием Escape:
Выделите на Форме ComboBox и перейдите в Инспектор объектов, на вкладку Events. Щёлкните дважды по обработчику OnKeyPress. Система Delphi создаст заготовку обработчика. Напишите:
  begin
   if Key=#13 then
      ComboBox1.Items.Add(ComboBox1.Text);
   if Key=#27 then
      ComboBox1.Items.Delete(ComboBox1.Items.Count-1);
  end ;
Key - определённая в этом обработчике переменная, содержащая код нажатой клавиши, #13 и #27 - коды клавиш Enter и Escape соответственно. Items.Count - количество содержащихся в компоненте строк. Так как отсчёт строк идёт от нуля, мы отнимаем единицу.

После очередного удаления количество строк меняется, таким образом, Items.Count-1 всегда указывает на последнюю строку. Последовательно нажимая Escape, мы можем удалить все строки. Командой
   ComboBox1.Items.Delete(0);
можно добиться того же эффекта, только удаляться будут первые строки. Впрочем, чтобы стереть всё сразу, есть метод Clear!

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

   ListBox1.Items.SaveToFile(' Имя_файла.txt ') ;

Впрочем, расширение можно поставить любое по желанию, не обязательно .txt, как и вообще без него обойтись. Но расширение .txt позволит легко открыть файл стандартным виндовским Блокнотом, что бывает очень удобно на этапе написания программы!
Для загрузки служит метод LoadFromFile:

   ListBox1.Items.LoadFromFile(' Имя_файла.txt ') ;

Что делать, если в своей программе мы не работаем с компонентами Combobox, ListBox или Memo, а сохранять информацию нужно? Берём один из компонентов и делаем его невидимым, для этого в Инспекторе Объектов ставим в свойство Visible значение False. Функциональность его от этого не изменится!

Последний штрих - создадим программу, сохраняющую своё положение на экране в момент закрытия и там же открывающуюся. Нам нужно сохранить два параметра - значения свойств Формы Left и Top, это расстояние от левого и верхнего краёв экрана соответственно. Значения эти выражаются в пикселях и имеют тип Integer. Необходимо перевести эти числа в строку (тип String) с помощью оператора IntToStr. Итак, разместите на Форме невидимый ListBox, щёлкните по пустому месту Формы, чтобы её свойства появились в Инспекторе объектов, и перейдите на вкладку Events. Щёлкните по обработчику OnClose и в созданной заготовке напишите:

  begin
   ListBox1.Items.Clear;
   ListBox1.Items.Add(IntToStr(Form1.Left));
   ListBox1.Items.Add(IntToStr(Form1.Top));
   ListBox1.Items.SaveToFile('MyFormPos.txt');
  end ;

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

  begin
   if FileExists('MyFormPos.txt') then
    begin
     ListBox1.Items.LoadFromFile('MyFormPos.txt');
     Form1.Left:=StrToInt(ListBox1.Items[0]);
     Form1.Top:=StrToInt(ListBox1.Items[1]);
    end ;
  end ;

   В первой строке происходит проверка на существование файла, ведь если его не будет, произойдёт ошибка. Впрочем, программа после выдачи предупреждения откроется в том месте, где была на этапе проектирования, а при закрытии нужный файл будет воссоздан!
   Затем в логических скобках begin / end содержится сам код, который будет выполнен только при наличии файла MyFormPos.txt в папке с программой, так как используется относительный путь. Можно указать конкретное местоположение, например, C:\Program Files\MyProg\MyFormPos.txt.

Урок Delphi 8. Работа с дополнительными формами Delphi

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

   Ввести новую форму в программу проще всего нажатием на кнопочку на главном окне Delphi. Также есть и соответствующая команда меню File -» New -» Form

Форма создаётся вместе с новым модулем, описывающим её работу. Сразу же покажем, как удалить Форму из программы. Для этого также есть кнопочка, и команда меню Project -» Remove from project.... Так как Форма создаётся вместе с её модулем, то в появившемся окошке нужно выбрать модуль, который и будет удалён из проекта вместе с Формой:

Сразу возникает вопрос, а что будет, если попытаться удалить и модуль Unit1, что останется?. Выполните команду Project -» View Sourse. В редакторе кода появится новая вкладка, на которой будет отображён код Главного Окна программы (не Главной Формы, а именно Окна. В Windows ведь все объекты рассматриваются как окна.) Главное окно невидимо, но управляет всем проектом, и может работать вообще без Форм. Туда можно вставлять свой код, и писать нехилые программы, как в классическом Паскале.

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

   Во-первых, нужно отменить автосоздание форм. Выполните команду меню Project -» Options... В появившемся окошке отображаются Main form (главная Форма), Auto-create (автосоздаваемые) и Available (доступные) формы проекта. Нам нужно перевести Форму из разряда автосоздаваемых в разряд доступных Форм. Делается это нажатием кнопки " > " (обратная операция - нажатием кнопки " < "):

Таким образом, главная Форма Form1 создаётся сама, а дополнительную форму Form2 мы создадим в программе при необходимости.

   Если этого ничего мы не предприняли (что вполне допустимо при малом количестве дополнительных форм), то для появления новой Формы на экране достаточно написать:

   Form2.Show; // в случае обычной Формы
   Form2.ShowModal; // в случае модальной Формы

Если же мы перевели дополнительные Формы в разряд доступных, то перед каждым вызовом такой Формы необходимо делать проверку на существование Формы (оператором Assigned) таким образом:

   if (not Assigned(Form2)) then   // проверка существования Формы (если нет, то
       Form2:=TForm2.Create(Self);    // создание Формы)
   Form2.Show; // (или Form2.ShowModal) показ Формы

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

   При попытке компилирования программы, содержащей вызов второй формы, Delphi выдаст такой запрос:

означающий:

Нужно разрешить, и в начале модуля перед директивой
{$R *.dfm}
будет добавлена фраза
uses Unit2;
В принципе, можно добавить её туда перед компиляцией "ручками", и тогда запроса не будет. Но смысл? Отвечаем "Yes" и снова жмём F9.

   Первым делом введём в форму операцию её закрытия! Сделать это можно несколькими способами. Возьмём кнопку, напишем "Закрыть" и в обработчике OnClick напишем:

Form2.Close; // В принципе, достаточно просто Close;

   Этот же оператор работает при вызове его из меню формы, если меню, конечно, туда ввести (компонент MainMenu на вкладке Standard), о чём в дальнейшем обязательно поговорим!

   Теперь же необходимо рассмотреть способ закрытия Формы, который относится именно к модальным формам. Он используется диалоговыми окнами с вопросом, требующим подтверждения, и в других аналогичных случаях. На Форме нужно расположить несколько кнопок, нажатие которых предполагает соответствующий ответ: "Да", "Нет", "Отмена", и т.д.
   У каждой кнопки есть свойство ModalResult, среди значений которой mrYes, mrNo, mrCansel и другие (посмотрите!). Значение ModalResult выбранной кнопки передаётся свойству ModalResult Формы. Это свойство отсутствует в списке свойств Формы, которые можно увидеть в Инспекторе Объектов, но программно оно доступно (напишите " Form2 ", поставьте точку и поищите в появившемся списке!).
   Нажатие кнопки со значением свойства ModalResult, отличного от mrNone, приводит к закрытию Формы, даже если у кнопки отсутствует обработчик нажатия! Затем можно проанализировать свойство ModalResult Формы и выяснить, какой же ответ на поставленный вопрос дал пользователь:

procedure TForm1.Button1Click(Sender: TObject);
begin
Form2.ShowModal;
if Form2.ModalResult=mrYes then   // Этот оператор будет доступен только после закрытия Form2
  Form1.Caption:='Пользователь ответил положительно!';
end;

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

Для этого необходимо указывать уже имя модуля. Например, для обращения к переменной X из модуля Unit2 пишем так: Unit2.X.
   Имеющейся возможности укрыть данные от использования в других модулях касаться пока не будем.

   В момент закрытия Формы часто в программе необходимо выполнить определённые операции. Делается это в обработчике события OnClose Формы. А теперь рассмотрим блокировку закрытия Формы.

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

В этом обработчике определена переменная логического типа CanClose. Форма будет закрыта только в том случае, когда
   CanClose:=True;
Например, если создать такой обработчик OnCloseQuery основной Формы программы:

procedure TForm1.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
begin
  CanClose:=False;
end;

то пользователь просто не сможет закрыть программу иначе как через Диспетчер задач Windows!

Урок Delphi 9. Создаём и используем подпрограммы Delphi

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

   Вообще, существует методика программирования "сверху вниз". Методика программирования "сверху вниз" разбивает задачу на несколько более простых, которые оформляются в виде подпрограмм. Те, в свою очередь, при необходимости также делятся до тех пор, пока стоящие перед программистом проблемы не достигнут приемлемого уровня сложности (то есть простоты!).

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

   И процедуры, и функции позволяют добиться одинаковых результатов. Но разница всё же есть.

   Процедура Delphi просто выполняет требуемые операции, но никаких результатов своих действий не возвращает. Результат - в тех изменениях, которые произошли в программе в процессе выполнения этой процедуры.

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

   Функция Delphi также позволяет выполнить всё перечисленное, но дополнительно возвращает результат в присвоенном ей самой значении. То есть вызов функции может присутствовать в выражении справа от оператора присваивания. Таким образом, функция - более универсальный объект!

   Описание подпрограммы состоит из ключевого слова procedure или function, за которым следует имя подпрограммы со списком параметров, заключённых в скобки. В случае функции далее ставится двоеточие и указывается тип возвращаемого значения.

Обычная точка с запятой далее - обязательна! Сам код подпрограммы заключается в "логические скобки" begin/end. Для функции необходимо в коде присвоить переменной с именем функции или специальной зарезервированной переменной Result (предпочтительно) возвращаемое функцией значение. Примеры:

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

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

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

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

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

   Теперь пример. Напишем программу суммирования двух чисел. Она будет состоять из Формы, на которой будет кнопка (компонент Button), по нажатию на которую будет выполняться наша подпрограмма, и двух строк ввода (компоненты Edit), куда будем вводить операнды. Начнём с процедуры.

var
  Form1: TForm1;
  A, B, Summa: Integer;
  procedure Sum(A, B: Integer);

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
 A:=StrToInt(Edit1.Text);
 B:=StrToInt(Edit2.Text);
 Sum(A, B);
 Caption:=IntToStr(Summa);
end;

procedure Sum(A, B: Integer);
begin
 Summa:=A+B;
end;

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

var
  Form1: TForm1;
  A, B, Summa: Integer;
  function Sum(A, B: Integer): Integer;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
 A:=StrToInt(Edit1.Text);
 B:=StrToInt(Edit2.Text);
 Summa:=Sum(A, B);        // На мой взгляд, сейчас более понятно, откуда что берётся
 Caption:=IntToStr(Summa);
end;

function Sum(A, B: Integer): Integer;
begin
 Result:=A+B;
end;

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

Поэтому используется передача не самих значений элементов (передача "по значению", как в предыдущих примерах), а ссылки на имя переменной или константы (передача "по имени"). Достигается это вставкой перед теми параметрами, которые мы хотим передать по имени, ключевого слова var.

function Sum(A, B: Integer; var Arr: array[1..1000000] of Integer): Integer;

   Если взглянуть на описание нашей подпрограммы и описание обработчика нажатия кнопки (это тоже подпрограмма!), который был создан Delphi, то видим, что перед именем обработчика (Button1Click) стоит TForm1. Как мы знаем, в Delphi точкой разделяется объект и его атрибуты (свойства и методы).

Таким образом, Delphi создаёт Button1Click как метод объекта Form1. Причём, буква T перед объектом говорит о том, что Button1Click не просто метод объекта, а метод класса объекта. Не будем этим пока заморачиваться, а просто будем поступать также.

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

Button1.Width:=100;   //Ширина кнопки
   а не
Form1.Button1.Width:=100;

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

   Описав подпрограмму как метод класса, её описание мы должны поместить туда же, куда их помещает Delphi - в описание класса TForm1. Смотрите сами, где находится описание процедуры Button1Click. Для этого, поставив курсор внутрь подпрограммы Button1Click, нажмите CTRL+Shift и кнопку управления курсором "Вверх" или "Вниз" одновременно.

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

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

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

Пример. Вычисление факториала

   Вычисление факториала - классическая в программировании задача на использование рекурсии. Факториал числа N - результат перемножения всех чисел от 1 до N (обозначается N!):

N! = 1*2* ... *(N-1)*N = N*(N-1)!

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

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

Урок Delphi 10. Исключительные ситуации в Delphi

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

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

   Как в такой ситуации действует человек? Если он пытается что-то сделать, и это не получается - он идёт другим путём. Так же и компьютер, следующий программе, умеющей обрабатывать исключительные ситуации.

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

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

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

   Вот как выглядит оператор контроля исключительных ситуаций:

try
   основные операторы фрагмента;
except
   альтернативный вариант фрагмента;
end;

   Вначале производится попытка выполнить операторы секции try/except, содержащие основной вариант программы. При возникновении в каком-либо операторе этой секции исключительной ситуации остальные операторы секции пропускаются, и выполняется секция except/end. Если всё "проходит штатно", то секция except/end пропускается.

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

try
   операторы
finally
   заключительные действия
end;
   Основные операторы, находящиеся в секции try, могут пройти штатно, или вызвать исключительную ситуацию. Операторы заключительных действий, находящиеся в секции finally, будут выполнены в любом случае.

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

Таким образом, в случае ошибки ввода или вывода программа не прерывается. В конце участка с операторами ввода-вывода ставится директива, включающая автоконтроль: {$I+}. Затем анализируется результат вызова функции IOResult. Если функция IOResult (вызывается без параметров) возвращает 0, значит ошибок ввода-вывода на данном участке не было.

Вот какой пример использования директив {$I} и функции IOResult содержит справка системы Delphi:

var
  F: file of Byte;
begin
  if OpenDialog1.Execute then
  begin
    AssignFile(F, OpenDialog1.FileName);
    {$I-}
    Reset(F);
    {$I+}
    if IOResult = 0 then
    begin
      MessageDlg('File size in bytes: ' + IntToStr(FileSize(F)), mtInformation, [mbOk], 0);
      CloseFile(F);
    end
    else
      MessageDlg('File access error', mtWarning, [mbOk], 0);
  end;
end;

   Функция IOResult досталась Delphi в наследство от Turbo Pascal. Тот же самый фрагмент можно составить и с использованием оператора try. На мой взгляд, это удобнее и проще.

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

Или можно отключить реакцию системы на исключительные ситуации, тем самым давая возможность отработать специально для этого написанным фрагментам программы - нашим операторам try/except/end. Для этого откроем пункт системного меню Delphi Tools -> Debugger Options....

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

Урок Delphi 11. Обзор компонентов Delphi

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

Страница Standart

   Изучение Delphi естественным образом начинается со страницы палитры компонентов Standart. На этой странице расположены стандартные для Windows интерфейсные элементы, такие как главное и всплывающее меню, кнопка, однострочный и многострочный редакторы, переключатели, метки, списки, и некоторые другие компоненты, применяющиеся наиболее часто.

Страница Additional

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

Страница Win32

   Эта страница содержит компоненты, представляющие собой интерфейсные элементы для 32-разрядных операционных систем Windows 95/98/NT (В версии системы Delphi 2 эта страница называлась Win95). Использующие эти компоненты программы выглядят в стилистике последних версий операционных систем Windows.

Страница System

   На этой странице представлены компоненты, которые имеют различное функциональное назначение (например, Timer - очень важный в любой программе компонент), в том числе компоненты, поддерживающие стандартные для Windows технологии межпрограммного обмена данными OLE и DDE.

Урок Delphi 12. Работа со строками Delphi

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

• числовой формат, целый и дробный с плавающей точкой;
• формат времени, даты, даты-времени;
• преобразование символов к верхнему или нижнему регистру;
• сравнение строк, поиск в строке и копирование подстроки;
  и многие другие...

   Непосредственно сами строки Delphi поддерживают единственную операцию, так называемую операцию конкатенации, то есть присоединения. Несмотря на "научное" название, операция конкатенации выполняет очень простую процедуру. С помощью операции конкатенации одна строка присоединяется к другой:

var S, S1, S2: String;
begin
 S:=S1+S2;
end;

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

   function Length(S: String): Integer;

   Delphi работает со строками типа String, в котором длина строки записывается в начале строки, перед первым символом. Поэтому индекс первого символа в строке не 0, а 1. То есть, если:

S:='Строка типа String';

то S[1] - символ 'С', S[2] - символ 'т', последний символ в строке - S[Length(S)], равный 'g'.

   Однако часто приходится иметь дело со строками типа PChar, которые использует операционая система Windows. В строках типа PChar длина строки определяется специальным символом конца строки - #0. Поэтому для использования функций Windows тип String необходимо предварительно переводить в тип PChar. Преобразование типа String в тип PChar выполняет функция

   function PChar(S: String): PChar;

   Для полноценной работы со строками Delphi используются следующие стандартные процедуры и функции:

Функции преобразования в числовой формат и обратно

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

Процедуры и функции преобразования дат и времени

Сначала собственно функции, предоставляющие информацию о текущих дате и времени:

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

Наконец, собственно, функции, переводящие дату и время из формата TDateTime в строчный формат:

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

Следующие функции сравнивают две строки между собой:

Следующие функции осуществляют поиск в текущей строке подстроки, вставляют, удаляют или заменяют подстроку:

Наконец, функция копирования части строки:

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

function RealToStr(X: Real; Count: Integer): String;//Count - количество цифр после запятой
var S: String;
    N: Integer;
begin
  S:=FloatToStr(X); //после запятой - длинная последовательность цифр
//DecimalSeparator - константа, содержащая истинный разделитель целой и дробной частей числа   N:=Pos(DecimalSeparator, S); //позиция запятой в строке
//вычисляем длину строки с нужным количеством знаков после запятой:
  if N=0//если в строке нет запятой - это целое число, и
    then N:=Length(S)//тогда просто выводим это число
    else N:=N+Count;//иначе вычисляем длину строки
  Result:=Copy(S, 1, N);//копируем часть строки в результат
end;


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

Это тоже интересно:

GO программирование: самое начало работы.

Пишем первую программу на Go.