Оглавление
В основе среды Borland Delphi лежит одноименный язык программирования - Delphi, ранее известный как Object Pascal. При разработке программы среда Delphi выполняет свою часть работы - создает пользовательский интерфейс согласно вашему дизайну, а вы выполняете свою часть - пишите обработчики событий на языке Delphi. Объем вашей работы зависит от программы: чем сложнее алгоритм, тем тяжелее ваш труд. Необходимо заранее усвоить, что невозможно заставить средство разработки делать всю работу за вас. Некоторые задачи среда Delphi действительно полностью берет на себя, например создание простейшей программы для просмотра базы данных. Однако большинство задач не вписываются в стандартные схемы - вам могут понадобиться специализированные компоненты, которых нет в палитре компонентов, или для задачи может не оказаться готового решения, и вы вынуждены будете решать ее старым дедовским способом - с помощью операторов языка Delphi. Поэтому мы настоятельно рекомендуем вам не игнорировать эту главу, поскольку на практике вы не избежите программирования. Мы решили изложить язык в одной главе, не размазывая его по всей книге, чтобы дать вам фундаментальные знания и обеспечить быстрый доступ к нужной информации при использовании книги в качестве справочника.
Алфавит
Буквы
Изучая в школе родной язык, вы начинали с букв, слов и простейших правил синтаксиса. Для постижения основ языка Delphi мы предлагаем вам сделать то же самое.
Текст программы на языке Delphi формируется с помощью букв, цифр и специальных символов.
Буквы - это прописные и строчные символы латинского алфавита и символ подчеркивания:
a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z _
Цифры представлены стандартной арабской формой записи:
0 1 2 3 4 5 6 7 8 9
Специальные символы
+ - * / = < > [ ] , . : ; ' ( ) { } @ # $ & ^
применяются в основном в качестве знаков арифметических операций, разделителей, ограничителей и т.д. Из специальных символов формируются составные символы:
<> <= >= .. (. .) (* *) // :=
Они служат, в частности, для обозначения операций типа "не равно", "больше или равно", указания диапазонов значений, комментирования программы, т.д.
Все перечисленные знаки отражены на клавиатуре и при нажатии соответствующих клавиш появляются на экране. Как вы видите, среди них нет русских букв, хотя на клавиатуре вашего компьютера они наверняка присутствуют. Дело в том, что такие буквы в языке Delphi несут чисто информационную нагрузку и используются только в качестве данных или при написании комментария к программе.
Числа
Одно и то же число можно записать самыми разными способами, например:
15 { целое }
15.0 { вещественное с фиксированной точкой }
1.5E01 { вещественное с плавающей точкой }
$F { шестнадцатиричное }
В языке Delphi имеется возможность применять все способы записи, но чаще всего используют целые и вещественные числа.
Целые числа состоят только из цифр и знака + или -. Если знак опущен и число не равно 0, то оно рассматривается как положительное, например:
0 { 0 интерпретируется как целое число }
17 { положительное целое число }
-39 { отрицательное целое число }
Вещественные числа содержат целую и дробную части, разделенные точкой:
0.0 { 0 интерпретируется как вещественное число }
133.5 { положительное вещественное число }
-0.7 { отрицательное вещественное число }
Вещественные числа могут быть представлены в двух формах: с фиксированной и плавающей точкой.
Форма с фиксированной точкой совпадает с обычной записью чисел, например:
27800 { точка в конце числа опущена }
0.017
3.14
Форма с плавающей точкой используется при работе с очень большими или очень малыми числами. В этой форме число, стоящее перед буквой E, умножается на 10 в степени, указанной после буквы E:
7.13E+14 { 7.13 x 1014 }
1.7E-5 { 1.7 x 10-5 }
3.14E00 { 3.14 x 100 = 3.14}
Число, стоящее перед буквой E, называется мантиссой, а число после буквы E - порядком.
В этой статье мы чаще будем использовать форму с фиксированной точкой, так как она воспринимается лучше второй формы и совпадает с привычной математической записью чисел.
Слова-идентификаторы
Неделимые последовательности символов алфавита образуют слова (идентификаторы). Идентификатор начинается с буквы и не должен содержать пробелов. После первого символа допускаются буквы и цифры. Напоминаем, что символ подчеркивания считается буквой.
При написании идентификаторов могут использоваться как прописные, так и строчные буквы (между ними не делается различий). Длина идентификатора может быть любой, но значимы только первые 255 символов (вполне достаточный предел, не так ли). Примеры написания идентификаторов приведены ниже:
Правильно |
Неправильно |
| RightName | Wrong Name |
| E_mail | |
| _5inches | 5inches |
Все идентификаторы подразделяются на зарезервированные слова, стандартные директивы, стандартные идентификаторы и идентификаторы программиста.
Зарезервированные (ключевые) слова составляют основу языка Delphi, любое их искажение вызовет ошибку компиляции. Вот полный перечень зарезервированных слов:
and as asm array begin case class const constructor destructor dispinterface div do downto else end except exports file finally finalization for function goto if implementation in inherited inline initialization interface is label library mod nil not object of or out packed procedure program property raise record repeat resourcestring set shl shr string then threadvar to try type unit until uses var while with xor
Стандартные директивы интерпретируются либо как зарезервированные слова, либо как идентификаторы программиста в зависимости от контекста, в котором используются. Вот они:
absolute abstract assembler at automated cdecl default dispid dynamic export external far forward index message name near nodefault on overload override pascal private protected public published read register reintroduce resident stdcall stored virtual write
Стандартные идентификаторы - это имена стандартных подпрограмм, типов данных языка Delphi, т.д. В качестве примера приведем имена подпрограмм ввода и вывода данных и нескольких математических функций. Вы, без сомнения, сами угадаете их назначение:
Read Write Sin Cos Exp Ln
Идентификаторы программиста определяются программистом, т.е вами, и носят произвольный характер. Если идентификатор состоит из двух или более смысловых частей, то для удобства их лучше выделять заглавной буквой или разделять символом подчеркивания:
LowProfit AverageProfit HighProfit Price_One Price_Two Price_Sum
Имя идентификатора обязательно должно нести смысловую нагрузку, тогда вы сможете читать программу как книгу и не потратите время на расшифровку непонятных обозначений.
Комментарии
С помощью комментариев вы можете пояснить логику работы своей программы. Комментарий пропускается компилятором и может находиться в любом месте программы. Комментарием является:
{ Любой текст в фигурных скобках }
(* Любой текст в круглых скобках со звездочками *)
// Любой текст от двойной наклонной черты до конца строки
Если за символами { или (* сразу идет знак доллара $, то текст в скобках считается не комментарием, а директивой компилятора. Большинство директив компилятора являются переключателями, которые включают или выключают те или иные режимы компиляции, оптимизацию, контроль выхода значений из допустимого диапазона, переполнение, т.д. Примеры таких директив:
{$OPTIMIZATION ON}
{$WARNINGS ON}
{$RANGECHECKS OFF}
Данные
Понятие типа данных
Программа в процессе выполнения всегда обрабатывает какие-либо данные. Данные могут представлять собой целые и дробные числа, символы, строки, массивы, множества и др. Так как компьютер всего лишь машина, для которой данные - это последовательность нулей и единиц, он должен абсолютно точно "знать", как их интерпретировать. По этой причине все данные в языке Delphi подразделены на типы. Для описания каждого типа данных существует свой стандартный идентификатор: для целых - Integer, для дробных - Real, для строк - string и т.д. Программист может образовывать собственные типы данных и давать им произвольные имена (о том, как это делается, мы поговорим чуть позже).
Тип данных показывает, какие значения принимают данные и какие операции можно с ними выполнять. Каждому типу данных соответствует определенный объем памяти, который требуется для размещения данных. Например, в языке Delphi существует тип данных Byte. Данные этого типа принимают значения в целочисленном диапазоне от 0 до 255, могут участвовать в операциях сложения, вычитания, умножения, деления, и занимают 1 байт памяти.
Все типы данных в языке Delphi можно расклассифицировать следующим образом:
- простые типы данных. Они в свою очередь подразделяются на порядковые и вещественные типы данных. К порядковым типам относятся целочисленные, символьные, булевские, перечисляемые и интервальные типы данных;
- временной тип данных. Служит для представления значений даты и времени;
- строковые типы данных. Служат для представления последовательностей из символов, например текста;
- составные типы данных (в некоторых источниках - структурированные типы данных). Формируются на основе всех остальных типов. К ним относятся массивы, множества, записи, файлы, классы и ссылки на классы;
- процедурные типы данных. Позволяют манипулировать процедурами и функциями как данными программы;
- указательные типы данных. Данные этих типов хранят адреса других данных, с их помощью организуются различные динамические структуры: списки, деревья и т.д.;
- тип данных с непостоянным типом значений. Служит для представления значений, тип которых заранее неизвестен; с его помощью легко организуется работа со списком разнотипных значений;
Некоторые предопределенные типы данных делятся на фундаментальные и обобщенные типы. Данные фундаментальных типов имеют неизменный диапазон значений и объем занимаемой памяти на всех моделях компьютеров. Данные обобщенных типов на различных моделях компьютеров могут иметь разный диапазон значений и занимать разный объем памяти. Деление на фундаментальные и обобщенные типы характерно для целых, символьных и строковых типов данных.
По ходу изложения материала мы рассмотрим все перечисленные типы данных и более подробно объясним их смысл и назначение в программе.
Константы
Данные, независимо от типа, имеют некоторое значение и в программе предстают как константы или переменные. Данные, которые получили значение в начале программы и по своей природе изменяться не могут, называются константами. Константами, например, являются скорость света в вакууме и соотношение единиц измерения (метр, сантиметр, ярд, фут, дюйм), которые имеют научно обоснованные или традиционно принятые постоянные значения. Константы описываются с помощью зарезервированного слова const. За ним идет список имен констант, каждому из которых с помощью знака равенства присваивается значение. Одно присваивание отделяется от другого с помощью точки с запятой. Тип константы распознается компилятором автоматически, поэтому его не надо указывать при описании. Примеры констант:
const DelphiLanguage = 'Object Pascal'; KylixLanguage = DelphiLanguage; Yard = 914.4; Foot = 304.8;
После такого описания для обращения к нужному значению достаточно указать лишь имя соответствующей константы.
Значение константы можно задавать и выражением. Эту возможность удобно использовать для комплексного представления какого-либо понятия. Например, временной промежуток, равный одному месяцу, можно задать так:
const SecondsInMinute = 60; SecondsInHour = SecondsInMinute * 60; SecondsInDay = SecondsInHour * 24;
Очевидно, что, изменив базовую константу SecondsInMinute, можно изменить значение константы SecondsInDay.
При объявлении константы можно указать ее тип:
const Percent: Double = 0.15; FileName: string = 'HELP.TXT';
Такие константы называются типизированными; их основное назначение - объявление константных значений составных типов данных.
Переменные
Переменные в отличие от констант могут неограниченное число раз менять свое значение в процессе работы программы. Если в начале программы некоторая переменная X имела значение 0, то в конце программы X может принять значение 10000. Так бывает, например, при суммировании введенных с клавиатуры чисел.
Переменные описываются с помощью зарезервированного слова var. За ним перечисляются идентификаторы переменных, и через двоеточие указывается их тип. Каждая группа переменных отделяется от другой группы точкой с запятой. Например:
var Index: Integer; // переменная целого типа данных FileName: string; // переменная строкового типа данных Sum, Profit: Double; // группа переменных вещественного типа данных
В теле программы переменной можно присвоить значение. Для этого используется составной символ :=, например:
Sum := 5000.0; // переменной Sum присваивается 5000 Percent := 0.15; // переменной Percent присваивается 0.15 Profit := Sum * Percent; // вычисляется произведение двух переменных // и его результат присваивается переменной // Profit
Вы можете присвоить значение переменной непосредственно при объявлении:
var Index: Integer = 1; Delimiter: Char = ';';
Объявленные таким образом переменные называются инициализированными. На инициализированные переменные накладывается ограничение: они не могут объявляться в подпрограммах (процедурах и функциях). Если переменная не инициализируется при объявлении, то по умолчанию она заполняется нулем.
Каждый используемый в программе элемент данных должен быть описан в разделе const или var. Исключение составляют данные, заданные непосредственно значением, например:
Write(100, 200); // 100 и 200 - данные, заданные значением
Простые типы данных
Целочисленные типы данных
Целочисленные типы данных применяются для описания целочисленных данных. Для решения различных задач могут потребоваться различные целые числа. В одних задачах счет идет на десятки, в других - на миллионы. Соответственно в языке Delphi имеется несколько целочисленных типов данных, среди которых вы можете выбрать наиболее подходящий для своей задачи.
Фундаментальные типы данных:
Тип данных |
Диапазон значений |
Объем памяти (байт) |
| Byte | 0..255 | 1 |
| Word | 0..65535 | 2 |
| Shortint | -128..127 | 1 |
| Smallint | -32768..32767 | 2 |
| Longint | -2147483648..2147483647 | 4 |
| Longword | 0.. 4294967295 | 4 |
| Int64 | -2^63..2^63-1 | 8 |
Обобщенные типы данных:
Тип данных |
Диапазон значений |
Формат (байт) |
| Cardinal | 0.. 4294967295 | 4* |
| Integer | -2147483648..2147483647 | 4* |
ПРИМЕЧАНИЕ
* - количество байт памяти, требуемых для хранения переменных обобщенных типов данных, приведено для 32-разрядных процессоров семейства x86.
Пример описания целочисленных данных:
var X, Y: Integer; TextLength: Cardinal; FileSize: Longint;
Позволим себе дать небольшой совет. При программировании алгоритмов предпочтение следует отдавать обобщенным типам даных, поскольку они позволяют достичь максимальной производительности программ при переходе на другие модели компьютеров (например, при переходе на компьютеры, построенные на основе новых 64-разрядных процессоров). Переменные обобщенных типов данных могут храниться в памяти по-разному в зависимости от конкретной модели компьютера, и для работы с ними компилятор может генерировать наиболее оптимальный код. Однако при использовании переменных обобщенных типов данных ни в коем случае нельзя полагаться на формат их хранения в памяти, в частности на размер.
Вещественные типы данных
Вещественные типы данных применяются для описания вещественных данных с плавающей или с фиксированной точкой
Тип данных |
Диапазон значений |
Мантисса |
Объем памяти (байт) |
| Real | 5.0*10-324..1.7*10308 | 15-16 | 8* |
| Real48 | 2.9*10-39..1.7*1038 | 11-12 | 6 |
| Single | 1.5*10-45..3.4*1038 | 7-8 | 4 |
| Double | 5.0*10-324..1.7*10308 | 15-16 | 8 |
| Extended | 3.4*10-4932..1.1*104932 | 19-20 | 10 |
| Comp | -9223372036854775808 .. 9223372036854775807 | 19-20 | 8 |
| Currency | -922337203685477.5808 .. 922337203685477.5807 | 19-20 | 8 |
ПРИМЕЧАНИЕ
* -количество байт памяти, требуемых для хранения переменных обобщенных типов данных, приведено для 32-разрядных процессоров семейства x86.
Пример описания вещественных данных:
var X, Y: Double; Z: Extended;
Необходимо отметить, что тип Real является обобщенным типом данных и по отношению к нему справедливо все то, что было сказано о типах Integer и Cardinal.
Символьные типы данных
Символьные типы применяются для описания данных, значением которых является буква, цифра, знак препинания и другие символы. Существуют два фундаментальных символьных типа данных: AnsiChar и WideChar (таблица 2.3). Они соответствуют двум различным системам кодировки символов. Данные типа AnsiChar занимают один байт памяти и кодируют один из 256 возможных символов расширенной кодовой таблицы ANSI, в то время как данные типа WideChar занимают два байта памяти и кодируют один из 65536 символов кодовой таблицы Unicode. Кодовая таблица Unicode - это стандарт двухбайтовой кодировки символов. Первые 256 символов таблицы Unicode соответствуют таблице ANSI, поэтому тип данных AnsiChar можно рассматривать как подмножество WideChar.
Фундаментальные типы данных:
Тип данных |
Диапазон значений |
Объем памяти (байт) |
| AnsiChar | Extended ANSI character set | 1 |
| WideChar | Unicode character set | 2 |
Обобщенный тип данных:
Тип данных |
Диапазон значений |
Формат (байт) |
| Char | Same as AnsiChar's range | 1* |
ПРИМЕЧАНИЕ
* - Тип данных Char является обобщенным и соответствует типу AnsiChar. Однако следует помнить, что в будущем тип данных Char может стать эквивалентным типу данных WideChar, поэтому не следует полагаться на то, что символ занимает в памяти один байт.
Пример описания переменной символьного типа:
var Symbol: Char;
В программе значения переменных и констант символьных типов заключаются в апострофы (не путать с кавычками!), например:
Symbol := 'A'; // Переменной Symbol присваивается буква A
Булевские типы данных
Булевские типы данных названы так в честь Георга Буля (George Boole), одного из авторов формальной логики. Диапазон значений данных булевских типов представлен двумя предопределенными константами: True - истина и False - ложь.
Тип данных |
Диапазон значений |
Объем памяти (байт) |
| Boolean | False (0), True (1) | 1 |
| ByteBool | False (0), True (не равно 0 | 1 |
| WordBool | False (0), True (не равно 0) | 2 |
| LongBool | False (0), True (не равно 0) | 4 |
Пример описания булевских данных:
var Flag: Boolean; WordFlag: WordBool; LongFlag: LongBool;
Булевские типы данных широко применяются в логических выражениях и в выражениях отношения. Переменные типа Boolean используются для хранения результатов логических выражений и могут принимать только два значения: False и True (стандартные идентификаторы). Булевские типы данных ByteBool, WordBool и LongBool введены в язык Delphi специально для совместимости с другими языками, в частности с языками C и C++. Все булевские типы данных совместимы друг с другом и могут одновременно использоваться в одном выражении.
Определение новых типов данных
Кроме стандартных типов данных язык Delphi поддерживает типы, определенные программистом. Новый тип данных определяется с помощью зарезервированного слова type, за которым следует идентификатор типа, знак равенства и описание. Описание завершается точкой с запятой. Например, можно определить тип, тождественный существующему типу:
type TUnicode = WideChar; // TUnicode тождественен типу WideChar TFloat = Double; // TFloat тождественен типу Double
Нетрудно заметить, что идентификаторы новых типов в примере начинаются заглавной буквой T (первая буква слова type). Такое соглашение о типах программиста принято разработчиками среды Delphi, но оно не является строгим. Тем не менее, мы рекомендуем его придерживаться, так как оно способствует более легкому восприятию исходного текста программы.
Синтаксическая конструкция type позволяет создавать новые порядковые типы: перечисляемые типы и интервальные типы.
Перечисляемые типы данных
Перечисляемый тип данных представляет собой список значений, которые может принимать переменная этого типа. Каждому значению поставлен в соответствие идентификатор, используемый в программе для указания этого значения.
type TDirection = (North, South, East, West);
На базе типа TDirection можно объявить переменную Direction и присвоить ей значение:
var Direction: TDirection; begin Direction := North; end.
На самом деле за идентификаторами значений перечисляемого типа стоят целочисленные константы. По умолчанию, первая константа равна 0, вторая - 1 и т.д. Существует возможность явно назначить значения идентификаторам:
type TSizeUnit = (Byte = 1, Kilobyte = 1024 * Byte, Megabyte = Kilobyte * 1024, Gigabyte = Megabyte * 1024);
Интервальные типы данных
Интервальный тип данных задается двумя константами, ограничивающими диапазон значений для переменных данного типа. Обе константы должны принадлежать одному из стандартных порядковых типов (но не вещественному и не строковому). Значение первой константы должно быть обязательно меньше значения второй. Например, определим интервальный тип TDigit:
type TDigit = 0..9; var Digit: TDigit; begin Digit := 5; Digit := 10; // Ошибка! Выход за границы диапазона end.
В операциях с переменными интервального типа данных компилятор генерирует код проверки на принадлежность диапазону, поэтому последний оператор вызовет ошибку. Это очень удобно при отладке, но иногда отрицательно сказывается на скорости работы программы. Для отключения контроля диапазона откройте окно Project Options, выберите страницу Compiler и снимите пометку пункта Range Checking.
Данные перечисляемых и интервальных типов занимают в памяти 1, 2 или 4 байта в зависимости от диапазона значений типа. Например, если диапазон значений не превышает 256, то элемент данных занимает один байт памяти.
Временной тип данных
Для представления значений даты и времени в среде Delphi существует тип TDateTime. Он объявлен тождественным типу Double. Целая часть элемента данных типа TDateTime соответствует количеству дней, прошедших с полночи 30 декабря 1899 года. Дробная часть элемента данных типа TDateTime соответствует времени дня. Следующие примеры поясняют сказанное:
Значение |
Дата |
Время |
| 0 | 30.12.1899 | 00:00:00 |
| 0.5 | 30.12.1899 | 12:00:00 |
| 1.5 | 31.12.1899 | 12:00:00 |
| -1.25 | 29.12.1899 | 06:00:00 |
| 35431.0 | 1.1.1997 | 00:00:00 |
Типы данных со словом type
Если в программе создается новый тип данных, тождественный уже существующему типу данных, то компилятор не делает никаких различий между ними (ни на этапе компиляции, ни на этапе исполнения программы). По сути, создается не новый тип данных, а псевдоним для уже существующего типа данных.
type TFileName = string;
В приведенном выше примере тип данных TFileName является псевдонимом для стандартного типа данных string.
Для того чтобы создать действительно новый тип данных, обладающий свойствами уже существующего типа данных, но не тождественный ему, необходимо использовать зарезервированное слово type:
type TFileName = type string;
Различие между таким способом создания типа и обычным (без слова type) проявится при изучении массивов, записей и классов. Чтобы подготовленный читатель уже сейчас понял, в чем оно состоит, забежим вперед и приведем поясняющий пример (новичкам советуем пропустить пример и вернуться к нему позже после изучения массивов):
type TType1 = array [1..10] of Integer; TType2 = type TType1; var A: TType1; B: TType2; begin B := A; // Ошибка! end.
В примере переменные A и B оказываются несовместимы друг с другом из-за слова type в описании типа TType2. Если же переменные A и B принадлежат простым типам данных, то оператор присваивания будет работать:
type TType1 = Integer; TType2 = type TType1; var A: TType1; B: TType2; begin B := A; // Работает end.
Операции
Выражения
Переменные и константы всех типов могут использоваться в выражениях. Выражение задает порядок выполнения действий над данными и состоит из операндов, круглых скобок и знаков операций. Операнды представляют собой константы, переменные и вызовы функций. Операции - это действия, выполняемые над операндами. Например, в выражении
(X + Y) / 2;
X, Y, 2 - операнды; '+', '/' - знаки операций; скобки говорят о том, что сначала выполняется операция сложения, потом - деления.
В простейшем случае выражение может состоять из одной переменной или константы. Круглые скобки используются, как и при записи обычных математических выражений, для управления порядком выполнения операций.
Операции в языке Delphi подразделяются на арифметические, операции отношения, логические (булевские), строковые, операцию получения адреса и другие. Выражения соответственно называются арифметическими, отношения, булевскими, строковыми и т.д. в зависимости от того, какого типа операнды и операции в них используются.
Арифметические операции
Арифметические операции наиболее часто используются в выражениях и выполняют арифметические действия над значениями операндов целочисленных и вещественных типов данных.
Операция |
Действие |
Тип операндов |
Тип результата |
| + | Сложение | Целый, вещественный | Целый, вещественный |
| - | Вычитание | Целый, вещественный | Целый, вещественный |
| * | Умножение | Целый, вещественный | Целый, вещественный |
| / | Деление | Целый, вещественный | Вещественный |
| div | Целочисленное деление | Целый | Целый |
| mod | Остаток от деления | Целый | Целый |
Операции сложения, вычитания и умножения соответствуют аналогичным операциям в математике. В отличие от них операция деления имеет три формы: обычное деление (/), целочисленное деление (div), остаток от деления (mod). Назначение каждой из операций станет понятным после изучения следующих примеров:
Выражение |
Результат |
| 6.8 - 2 | 4.8 |
| 7.3 * 17 | 124.1 |
| -(5 + 9) | -14 |
| -13.5 / 5 | -2.7 |
| -10 div 4 | -2 |
| 27 div 5 | 5 |
| 5 div 10 | 0 |
| 5 mod 2 | 1 |
| 11 mod 4 | 3 |
| -20 mod 7 | -6 |
| -20 mod 7 | -6 |
Операции отношения
Операции отношения выполняют сравнение двух операндов и определяют, истинно значение выражения или ложно (таблица 2.6). Сравниваемые величины могут принадлежать к любому порядковому типу данных. Результат всегда имеет булевский тип.
Эта группа операций специально разработана для реализации алгоритмических элементов типа "больше", "больше или равно" и т.п., которые имеются практически в каждой программе. деления (mod). Назначение каждой из операций станет понятным после изучения следующих примеров:
Операция |
Действие |
Выражение |
Результат |
| = | Равно | A = B | True, если A = B |
| <> | Не равно | A <> B | True, если A < B или A > B |
| < | Меньше | A < B | True, если A < B |
| > | Больше | A > B | True, если A > B |
| <= | Меньше или равно | A <= B | True, если A < B или A = B |
| >= | Больше или равно | A >= B | True, если A > B или A = B |
Типичные примеры операций отношения:
Выражение |
Результат |
| 123 = 132 | False |
| 123 <> 132 | False |
| 17 <= 19 | True |
| 17 > 19 | False |
| 7 >= 7 | True |
Булевские операции
Результатом выполнения логических (булевских) операций является логическое значение True или False. Операндами в логическом выражении служат данные типа Boolean.
Операция |
Действие |
Выражение |
A |
B |
Результат |
| not | Логическое отрицание | not A | True False | False True | |
| and | Логическое И | A and B | True True False False | True False True False | True False False False |
| or | Логическое ИЛИ | A or B | True True False False | True False True False | True True True False |
| xor | Исключающее ИЛИ | A xor B | True True False False | True False True False | False True True False |
Результаты выполнения типичных логических операций:
Выражение |
Результат |
| not (17 > 19) | True |
| (7 <= 8) or (3 < 2) | True |
| (7 <= 8) and (3 < 2) | False |
| (7 <= 8) xor (3 < 2) | True |
Операции с битами
Если операнды в булевской операции имеют целочисленный тип, то операция выполняется над битами операндов и называется побитовой. К побитовым операциям также относятся операции сдвига битов влево (shl) и вправо (shr).
Операция |
Действие |
Тип операндов |
Тип результата |
| not | Побитовое отрицание | Целый | Целый |
| and | Побитовое И | Целый | Целый |
| or | Побитовое ИЛИ | Целый | Целый |
| xor | Побитовое исключающее ИЛИ | Целый | Целый |
| shl | Сдвиг влево | Целый | Целый |
| shr | Сдвиг вправо | Целый | Целый |
Примеры побитовых операций:
Выражение |
Результат |
| not $FF00 | $00FF |
| $FF00 or $0FF0 | $FFF0 |
| $FF00 and $0FF0 | $0F00 |
| $FF00 xor $0FF0 | $F0F0 |
| $FF00 shl 4 | $F000 |
| $FF00 shr 4 | $0FF0 |
Очередность выполнения операций
При выполнении выражений одни операции выполняются раньше других. Например, в выражении
20 + 40 / 2
сначала произойдет деление (ибо скобок, меняющих естественный порядок выполнения операций, нет) и только потом - сложение. Выполнение каждой операции происходит с учетом ее приоритета. Не зная приоритета каждой операции, крайне трудно правильно записать даже самое простое выражение. Значения приоритетов для рассмотренных выше операций представлены в таблице.
Операция |
Приоритет |
Описание |
| -, not | Первый | Унарный минус, отрицаиие |
| *, /, div, mod, and | Второй | Операции типа умножение |
| +, -, or, xor | Третий | Операции типа сложение |
| =, <>, <,>, <=, >= | Четвертый | Операции отношения |
Чем выше приоритет (первый - высший), тем раньше операция будет выполнена.
Консольный ввод-вывод
Консольное приложение
Решение самой простой задачи на компьютере не обходится без операций ввода-вывода информации. Ввод данных - это передача данных от внешнего устройства в оперативную память для обработки. Вывод - обратный процесс, когда данные передаются после обработки из оперативной памяти на внешнее устройство. Внешним устройством может служить консоль ввода-вывода (клавиатура и монитор), принтер, гибкий или жесткий диск и другие устройства.
Сейчас мы рассмотрим лишь средства консольного ввод-вывода данных. Консоль - это клавиатура плюс монитор. С клавиатуры данные вводятся в программу, а на монитор выводятся результаты ее работы. Консольная модель ввода-вывода, при которой данные представляются потоком символов, не позволяет использовать графических средств. Однако она очень подходит для изучения языка Delphi, так как не загромождает примеры программ излишней информацией о среде и библиотеках программирования.
Итак, давайте последовательно создадим консольное приложение:
- Запустите среду Delphi, выберите в главном меню команду File / Close All, а затем - команду File / New.
- Выберите "Console Application" и нажмите "OK" (рисунок 2.1).
Рисунок 1. Окно среды Delphi для создания нового проекта
- В появившемся окне между ключевыми словами BEGIN и END введите следующие строчки (рисунок 2):
Writeln('Press Enter to exit...'); ReadLn;
Рисунок 2. Текст простейшей консольной программы в окне редактора кода
- Скомпилируйте и выполните эту программу, щелкнув на пункте Run / Run главного меню среды Delphi. На экране появится черное окно (рисунок 3), в левом верхнем углу которого будет содержаться текст "Press ENTER to exit..." ("Нажмите клавишу Enter ...").
Рисунок 3. Окно работающей консольной программы
- Нажмите в этом окне клавишу Enter - консольное приложение завершится.
Теперь, когда есть основа для проверки изучаемого материала, рассмотрим операторы консольного ввода-вывода. К ним относятся Write, Writeln, Read, Readln.
Консольный вывод
Инструкции Write и Writeln служат для вывода чисел, символов, строк и булевских значений на экран. Они имеют следующий формат:
Write(Y1, Y2, ... ,Yn); Writeln(Y1, Y2, ... ,Yn);
где Y1, Y2,..., Yn - константы, переменные и результаты выражений. Инструкция Writeln аналогична Write, но после своего выполнения переводит курсор в начало следующей строки.
Если инструкции Write и Writeln записаны без параметров:
Write; Writeln;
то это вызывает пропуск на экране соответственно одной позиции и одной строки.
Консольный ввод
Инструкции ввода обеспечивают ввод числовых данных, символов, строк для последующей обработки в программе. Формат их прост:
Read(X1, X2, ... ,Xn); Readln(X1, X2, ... ,Xn);
где X1, X2, ..., Xn - переменные, для которых осуществляется ввод значений. Пример:
Read(A); // Вводится значение переменной A Readln(B); // Вводится значение переменной B
Если одна инструкция вводит несколько значений:
Read(A, B);
то все эти значения надо набрать на клавиатуре, отделяя одно значение от другого пробелом, и нажать клавишу Enter.
Если вводится одно значение:
Read(C);
то его следует набрать и нажать клавишу Enter. С этого момента программа может обрабатывать введенное значение в соответствии с алгоритмом решаемой задачи.
Инструкция Readln отличается от Read только одним свойством: каждое выполнение инструкции Readln переводит курсор в начало новой строки, а после выполнения Read курсор остается в той же строке, где и был (потренеруйтесь - и вы быстро поймете разницу).
В простейшем случае в инструкциях Read и Readln параметры можно вообще не указывать:
Read; Readln;
Оба этих оператора останавливают выполнение программы до нажатия клавиши Enter.
Структура программы
Читатель уже достаточно много знает об отдельных элементах программы, пора изучить ее общую структуру. Синтаксически программа состоит из заголовка, списка подключаемых к программе модулей и программного блока:
Заголовок программы program <имя программы>;
Директивы компилятора {$<директивы>}
Подключение модулей uses <имя>, ..., <имя>;
Программный блок
Константы const ...;
Типы данных type ...;
Переменные var ...;
Процедуры procedure <имя>; begin ... end;
Функции function <имя>; begin ... end;
Тело программы begin
<операторы>
end.
Любая секция в программном блоке кроме тела программы может отсутствовать. Секции описания констант, типов данных, переменных, процедур и функций могут встречаться в программе любое количество раз и следовать в произвольном порядке. Главное, чтобы все описания были сделаны до того, как они будут использованы (иначе компилятор просто не поймет того, что вы написали).
Заголовок программы
Заголовок программы должен совпадать с именем программного файла. Он формируется автоматически при сохранении файла на диске и его не следует изменять вручную. Например, заголовок программы в файле Console.dpr выглядит так:
program Console;
Одним заголовком сказать можно немного, поэтому для подробного рассказа о назначении программы, нюансах алгоритма и других вещах применяют комментарий, например:
{****************************************************}
{ Демонстрационный пример }
{ A.Valvachev, K.Surkov, D.Surkov, Yu.Chetyrko }
{****************************************************}
После сведений о программе и разработчиках принято размещать директивы компилятора. Например, следующая директива всегда включается в текст консольного приложения:
{$APPTYPE CONSOLE}
Подключение модулей
Секция подключения модулей предназначена для встраивания в программу стандартных и разработанных вами библиотек подпрограмм и классов (о подпрограммах и классах читайте ниже). Эта секция состоит из зарезервированного слова uses и списка имен подключаемых библиотечных модулей. При написании программ, эмулирующих текстовый режим, подключается по крайней мере модуль SysUtils. В нем содержатся определения часто используемых типов данных и подпрограмм:
uses SysUtils;
С момента подключения все ресурсы модуля (типы данных, константы, переменные, процедуры и функции) становятся доступны программисту.
Программный блок
Важнейшим понятием в языке Delphi является так называемый блок. По своей сути блок - это программа в целом или логически обособленная часть программы, содержащая описательную и исполнительную части. В первом случае блок называется глобальным, во втором - локальным. Глобальный блок - это основная программа, он присутствует всегда; локальные блоки - это необязательные подпрограммы (они рассмотрены ниже). Локальные блоки могут содержать в себе другие локальные блоки (т.е. одни подпрограммы могут включать в себя другие подпрограммы). Объекты программы (типы, переменные и константы) называют глобальными или локальными в зависимости от того, в каком блоке они объявлены.
С понятием блока тесно связано понятие области действия программных объектов. Область действия трактуется как допустимость использования объектов в том или ином месте программы. Правило здесь простое: объекты программы можно использовать в пределах блока, где они описаны, и во всех вложенных в него блоках. Отсюда следует вывод - с глобальными объектами можно работать в любом локальном блоке.
Тело программы является исполнительной частью глобального блока. Именно из него вызываются для выполнения описанные выше процедуры и функции. Тело программы начинается зарезервированным словом begin (начало), далее следуют операторы языка, отделенные друг от друга точкой с запятой. Завершает тело программы зарезервированное слово end (конец) с точкой. Тело простейшей консольной программы выглядит так:
begin
Writeln('Press Enter to exit...');
Readln;
end.
На этом мы заканчиваем рассмотрение структуры программы и переходим к содержимому тела программы - операторам.