Then — Ключевое слово Delphi


Содержание

Программирование на языке Delphi
Глава 2. Основы языка Delphi. Часть 2

Операторы

Общие положения

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

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

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

Оператор присваивания

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

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

В общем случае для числовых типов данных действует следующее правило: выражение с более узким диапазоном возможных значений можно присвоить переменной с более широким диапазоном значений. Например, выражение с типом данных Byte можно присвоить переменной с типом данных Integer, а выражение с типом данных Integer можно присвоить переменной с типом данных Real. В таких случаях преобразование данных из одного представления в другое выполняется автоматически:

Исключение составляет случай, когда выражение принадлежит 32-разрядному целочисленному типу данных (например, Integer), а переменная — 64-разрядному целочисленному типу данных Int64. Для того, чтобы на 32-разрядных процессорах семейства x86 вычисление выражения происходило правильно, необходимо выполнить явное преобразование одного из операндов выражения к типу данных Int64. Следующий пример поясняет сказанное:

Оператор вызова процедуры

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

Составной оператор

Составной оператор представляет собой группу из произвольного числа операторов, отделенных друг от друга точкой с запятой и заключенную в так называемые операторные скобки — begin и end:

Частным случаем составного оператора является тело следующей программы:

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

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

Оператор ветвления if

Оператор ветвления if — одно из самых популярных средств, изменяющих естественный порядок выполнения операторов программы. Вот его общий вид:

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

Логика работы оператора if очевидна: выполнить оператор 1, если условие истинно, и оператор 2, если условие ложно. Поясним сказанное на примере:

В данном случае значение выражения А > В ложно, следовательно на экране появится сообщение C=8.

У оператора if существует и другая форма, в которой else отсутствует:

Логика работы этого оператора if еще проще: выполнить оператор, если условие истинно, и пропустить оператор, если оно ложно. Поясним сказанное на примере:

В результате на экране появится сообщение С=0, поскольку выражение А > В ложно и присваивание С := А + В пропускается.

Один оператор if может входить в состав другого оператора if. В таком случае говорят о вложенности операторов. При вложенности операторов каждое else соответствует тому then, которое непосредственно ему предшествует. Например

Конструкций со степенью вложенности более 2–3 лучше избегать из-за сложности их анализа при отладке программ.

Оператор ветвления case

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

Оператор case вычисляет значение переключателя (который может быть задан выражением), затем последовательно просматривает списки его допустимых значений в поисках вычисленного значения и, если это значение найдено, выполняет соответствующий ему оператор. Если переключатель не попадает ни в один из списков, выполняется оператор, стоящий за словом else. Если часть else отсутствует, управление передается следующему за словом end оператору.

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

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

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

Операторы повтора — циклы

Алгоритм решения многих задач требует многократного повторения одних и тех же действий. При этом суть действий остается прежней, но меняются данные. С помощью рассмотренных выше операторов трудно представить в компактном виде подобные действия в программе. Для многократного (циклического) выполнения одних и тех же действий предназначены операторы повтора (циклы). К ним относятся операторы for, while и repeat. Все они используются для организации циклов разного вида.

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

Оператор повтора for

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

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

Оператор for обеспечивает выполнение тела цикла до тех пор, пока не будут перебраны все значения параметра цикла от начального до конечного. После каждого повтора значение параметра цикла увеличивается на единицу. Например, в результате выполнения следующей программы на экран будут выведены все значения параметра цикла (от 1 до 10), причем каждое значение — в отдельной строке:

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

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

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

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

Например, в результате выполнения следующей программы на экран будут выведены значения параметра цикла в порядке убывания (от 10 до 1):

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

Оператор повтора repeat

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

Тело цикла выполняется до тех пор, пока условие завершения цикла (выражение булевского типа) не станет истинным. Оператор repeat имеет две характерные особенности, о которых нужно всегда помнить:

  • между словами repeat и until может находиться произвольное число операторов без операторных скобок begin и end;
  • так как условие завершения цикла проверяется после выполнения операторов, цикл выполняется, по крайней мере, один раз.

В следующем примере показано, как оператор repeat применяется для суммирования вводимых с клавиатуры чисел. Суммирование прекращается, когда пользователь вводит число 0:

Часто бывает, что условие выполнения цикла нужно проверять перед каждым повторением тела цикла. В этом случае применяется оператор while, который, в отличие от оператора repeat, содержит условие выполнения цикла, а не условие завершения.

Оператор повтора while

Оператор повтора while имеет следующий формат:

Перед каждым выполнением тела цикла происходит проверка условия. Если оно истинно, цикл выполняется и условие вычисляется заново; если оно ложно, происходит выход из цикла, т.е. переход к следующему за циклом оператору. Если первоначально условие ложно, то тело цикла не выполняется ни разу. Следующий пример показывает использование оператора while для вычисления суммы S = 1 + 2 + .. + N, где число N задается пользователем с клавиатуры:

Прямая передача управления в операторах повтора

Для управления работой операторов повтора используются специальные процедуры-операторы Continue и Break, которые можно вызывать только в теле цикла.

Процедура-оператор Continue немедленно передает управление оператору проверки условия, пропуская оставшуюся часть цикла (рисунок 4):

Рисунок 4. Схема работы процедуры-оператора Continue

Процедура-оператор Break прерывает выполнение цикла и передает управление первому оператору, расположенному за блоком цикла (рисунок 5):

Рисунок 5. Схема работы процедуры-оператора Break

Оператор безусловного перехода

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

Метка — это именованная точка в программе, в которую можно передать управление. Перед употреблением метка должна быть описана. Раздел описания меток начинается зарезервированным словом label, за которым следуют имена меток, разделенные запятыми. За последним именем ставится точка с запятой. Типичный пример описания меток:

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

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

Внимание! В соответствии с правилами структурного программирования следует избегать применения оператора goto, поскольку он усложняет понимание логики программы. Оператор goto использовался на заре программирования, когда выразительные возможности языков были скудными. В языке Delphi без него можно успешно обойтись, применяя условные операторы, операторы повтора, процедуры Break и Continue, операторы обработки исключений (последние описаны в главе 4).

Подпрограммы

Общие положения

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

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

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

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

Все процедуры и функции языка Delphi подразделяются на две группы: встроенные и определенные программистом.

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

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

Стандартные подпрограммы

Abs(X) Возвращает абсолютное значение аргумента X. Exp(X) Возвращает значение e x . Ln(X) Возвращает натуральный логарифм аргумента X. Pi Возвращает значение числа ?. Sqr(X) Возвращает квадрат аргумента X. Sqrt(X) Возвращает квадратный корень аргумента X.

Выражение

Результат Abs(–4) 4 Exp(1) 2.17828182845905 Ln(Exp(1)) 1 Pi 3.14159265358979 Sqr(5) 25 Sqrt(25) 5

ArcTan(X) Возвращает угол, тангенс которого равен X. Cos(X) Возвращает косинус аргумента X (X задается в радианах). Sin(X) Возвращает синус аргумента X (X задается в радианах).

Выражение

Результат ArcTan(Sqrt(3)) 1.04719755119660 Cos(Pi/3) 0.5 Sin(Pi/6) 0.5

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

Функции выделения целой или дробной части

Frac(X) Возвращает дробную часть аргумента X. Int(X) Возвращает целую часть вещественного числа X. Результат принадлежит вещественному типу. Round(X) Округляет вещественное число X до целого. Trunc(X) Возвращает целую часть вещественного числа X. Результат принадлежит целому типу.

Выражение

Результат Frac(2.5) 0.5 Int(2.5) 2.0 Round(2.5) 3 Trunc(2.5) 2

Функции генерации случайных чисел

Random Возвращает случайное вещественное число в диапазоне 0 ? X Входной Передается копия значения const Входной Передается копия значения либо ссылка на значение в зависимости от типа данных out Выходной Передается ссылка на значение var Входной и выходной Передается ссылка на значение

Таблица 10. Способы передачи параметров

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

Опущенные параметры процедур и функций

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

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

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

Перегрузка процедур и функций

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

В языке Delphi существует возможность дать двум и более процедурам (функциям) одинаковые идентификаторы при условии, что все такие процедуры (функции) отличаются списком параметров. Такая возможность называется перегрузкой. Для указания того, что процедура (функция) перегружена, служит стандартная директива overload. С ее помощью вышеприведенный пример можно переписать следующим образом:

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

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

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

Очевидно, что одно и то же число может интерпретироваться и как Longint, и как Shortint (например, числа 5 и –1). Логика компилятора в таких случаях такова: если значение фактического параметра попадает в диапазон значений нескольких типов, по которым происходит перегрузка, то компилятор выбирает процеудуру (функцию), у которой тип параметра имеет меньший диапазон значений. Например, вызов Print(5) будет означать вызов того варианта процедуры, который имеет тип параметра Shortint. А вот вызов Print(150) будет означать вызов того варианта процедуры, который имеет тип параметра Longint, т.к. число 150 не вмещается в диапазон значений типа данных Shortint.

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

Такая же ошибка возникает при использовании пользовательских типов данных, определенных через общий базовый тип.

Что делать в тех случаях, когда такая перегрузка просто необходима? Для этого пользовательский тип данных необходимо создавать с использованием ключевого слова type:

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

Вызов процедуры Increment с одним параметром вызовет неоднозначность:

Запрещается также перегружать функции, которые отличаются лишь типом возвращаемого значения.

Соглашения о вызове подпрограмм

В различных языках программирования используются различные правила вызова подпрограмм. Для того чтобы из программ, написанных на языке Delphi, возможно было вызывать подпрограммы, написанные на других языках (и наоборот), в языке Delphi существуют директивы, соответствующие четырем известным соглашениям о вызове подпрограмм: register, stdcall, pascal, cdecl.

Директива, определяющая правила вызова, помещается в заголовок подпрограммы, например:

Директива register задействует регистры процессора для передачи параметров и поэтому обеспечивает наиболее эффективный способ вызова подпрограмм. Эта директива применяется по умолчанию. Директива stdcall используется для вызова стандартных подпрограмм операционной системы. Директивы pascal и cdecl используются для вызова подпрограмм, написанных на языках Delphi и C/C++ соответственно.

Рекурсивные подпрограммы

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

Приведенная ниже программа содержит функцию Factorial для вычисления факториала. Напомним, что факториал числа определяется через произведение всех натуральных чисел, меньших либо равных данному (факториал числа 0 принимается равным 1):

Из определения следует, что факториал числа X равен факториалу числа (X – 1), умноженному на X. Математическая запись этого утверждения выглядит так:

Последняя формула используется в функции Factorial для вычисления факториала:

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

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

Упреждающее объявление процедур и функций

Для реализации алгоритмов с косвенной рекурсией в языке Delphi предусмотрена специальная директива предварительного описания подпрограмм forward. Предварительное описание состоит из заголовка подпрограммы и следующего за ним зарезервированного слова forward, например:

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

Процедурные типы данных

Наряду с уже известными типами данных в языке Delphi введен так называемый процедурный тип, с помощью которого обычные процедуры и функции можно интерпретировать как некоторую разновидность переменных. Определение процедурного типа состоит из зарезервированного слова procedure или function, за которым следует полное описание параметров. Для функции дополнительно указывается тип результата. Символические имена параметров никакой роли не играют, поскольку нигде не используются.

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

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

Дополнительная информация

За дополнительной информацией обращайтесь в компанию Interface Ltd.

Then — Ключевое слово Delphi

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

будет равен не 1, как в случае последовательного выполнения, а 6.2 .

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

Вот теперь X будет равен 1.

Помимо четырёх математических действий в Delphi доступно множество математических функций, таких, например, как тигонометрические, логарифмические, и т.д. Они становятся доступны в программе после добавления в секцию Interface uses модуля Math. Их описание также можно найти в модуле Math.pas (можно найти воспользовавшись поиском Windows). Многие из них можно реализовать и самому, но встроенные функции наверняка будут работать быстрее и лучше, т.к. написаны на языке ассемблера.

Логические выражения

Операторы Delphi

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

  • оператора присваивания
  • условного оператора
  • оператора цикла

С оператором присваивания «:=» мы уже знакомились в уроке Delphi 2. Он работает следующим образом. Переменная, стоящая в левой части оператора, становится равной той величине, которая находится справа. Типы этих величин должны совпадать. В выражении, стоящем справа, также может использоваться переменная, стоящая слева. С математической точки зрения это неправильно, но в программировании это означает, что из ячейки памяти берётся исходное значение, производятся вычисления, и результат записывается в эту же ячейку памяти, затирая прежнее значение. Пример:

В начале фрагмента переменная A равна 3, а в конце -25.

Условный оператор позволяет изменить порядок выполнения операторов в зависимости от выполнения некоторого условия. Вот как он записывается:

if условие then действие else альтернатива ;

Слова if (если), then (тогда), else (иначе) — зарезервированные. Действие и else альтернатива — это любые операторы Delphi, или несколько операторов, заключённых в логические скобки begin/end, или вызов подпрограммы. Если условие истинно, то выполняется действие , если ложно, то выполняется альтернатива .
Условие представляет собой логическое выражение. В нём сравниваются значения выражений (в том числе также и логических), вызов функций, возвращающих значения типа Boolean, и комбинирование этих значений с помощью логических операций:

Знак
операции
Название операции Логические операции могут комбинироваться с помощью связок:
and (логическое И)
or (логическое ИЛИ)
xor (исключающее ИЛИ)
Для некоторых типов данных есть дополнительные операции. Например, для множеств — оператор in, которая проверяет, входит ли некоторое значение в множество. Например:
X := [2, 4, 5, 7, 8, 10] ;
Выражение 2 in X истинно (имеет значение true);
Выражение 6 in X ложно (имеет значение false);
= Равно
<> Не равно
> Больше
= Больше или равно
действие ;
Счётчик — это переменная, которая должна быть объявлена перед логическим блоком, в котором оператор цикла расположен, и её тип должен относиться к одному из перечислимых типов, обычно 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 список меток ;

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

Из этого примера видно, что оператор end ; завершающий программу, никогда не будет выполнен, то есть программа зациклится. Именно поэтому, вообще, использование оператора перехода является плохим стилем программирования, и без его использования вполне можно обойтись использованием условных операторов и операторов цикла. Единственный случай, когда использование оператора goto может быть оправдано — это выход из нескольких вложенных циклов, что иначе требует применения нескольких операторов Break.

Пример. Сортировка одномерного массива

Рассматриваются процедуры программы, приводятся подробные комментарии. Также можно скачать проект в виде архива. Цикл while и операторы goto использованы только для демонстрации работы с ними. Здесь — более правильный вариант с применением цикла repeat и оператора break.
Параллельно замечу, что сортировка массива «методом пузырька» — неэффективный метод. Количество итераций (проходов цикла) растёт гораздо быстрее роста количества элементов, . Сортировка 50 000 элементов выполняется на моём компьютере секунд за пять. Но сортировка 100 000 — не за 10 секунд, а около 35 секунд! Можете поэкспериментировать, для этого достаточно во 2 варианте установить в описании массива нужное количество элементов.

Then — Ключевое слово Delphi

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

Об управляющих структурах

В реальных программах выполнение операций не бывает строго последовательным: постоянно требуются различные переходы, ветвления, повторения и т.д. Так, если мы обратимся к блок-схеме даже такого простого алгоритма, который требуется для игры «угадай число» (см. рис. 1.1), то увидим там целых два ветвления, причем оба с переходом.

Собственно за переход, в классическом варианте, отвечает небезызвестная инструкция безусловного перехода goto, которая в Pascal используется совместно с метками, декларируемыми в заголовочной части программы при помощи ключевого слова label. Использование инструкции безусловного перехода восходит корнями к тем временам, когда создавались первые высокоуровневые языки программирования, в том числе и Pascal. Она досталась им в наследство от низкоуровневых языков типа Assembler, в которых описание программы создавалось в виде, удобным для машины. Но на сегодня такой подход уже не востребован и вышел из употребления, вместе с безусловным переходом и инструкцией goto.

СОВЕТ
За 10 лет, прошедших с того момента, как я последний раз использовал язык Basic, мне ни разу не довелось ни использовать инструкцию goto в собственных программах, ни встретить ее в миллионах строк просмотренного кода. Вывод: она просто не нужна в Object Pascal, так что старайтесь не использовать goto!

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

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

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

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

Условный оператор if

Пожалуй, самой важной инструкцией для управления выполнением программы является условный оператор if. Именно он отвечает за ветвление, т.е. выполнение (или невыполнение) того или иного варианта кода в зависимости от условий. Оператор if используется совместно с ключевым словом then, а в том случае, когда предусмотрен альтернативный вариант выполнения — еще и с else. В целом синтаксис инструкции получается следующим:

В качестве условия может быть использовано любое выражение, которое может быть приведено к булевскому значению, т.е. к false или true. Как правило, это бывают операции сравнения, например:

if a > 5 then b := 10; if x <> 0 then y := 1 else y :=2;

В первом случае, если переменная a больше 5, то переменной b будет присвоено значение 10, если же a меньше или равно 5, то ничего выполнено не будет и управление будет передано следующему выражению. Во второй строке переменная x проверяется на ненулевое значение, и если x окажется числом, отличным от 0, то переменной y будет присвоено значение 1, в противном случае (если x равно 0) переменной y будет присвоено значение 2.

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

if a > 5 then begin b := 10; c := 20; end;

Как мы уже знаем, в соответствии с правилами синтаксиса Object Pascal, все то, что помещено между ключевыми словами begin и end, равно как и сами эти слова, воспринимаются как 1 оператор. Обратите внимание, что в конце поставлен пустой оператор — точка с запятой. В данном случае по правилам синтаксиса он здесь не обязателен, однако будет хорошим тоном завершать им каждый составной оператор, чтобы выделить тем самым окончание той инструкции, в которой он был применен. В данном случае получается, что мы использовали 2 оператора — составной и пустой, однако нарушения синтаксиса тут нет — компилятор сочтет, что пустой оператор следует уже после условного. Но если бы мы использовали еще и блок else, это привело бы к ошибке синтаксиса, поскольку между then и else допустима лишь 1 инструкция. Поэтому в таком случае точку с запятой следует разместить уже после оператора, следующего за else:

if a > 5 then begin b := 10; c := 20; end else begin b := 20; c := 15; end;

В тех случаях, когда требуется предусмотреть 3 или более вариантов исполнения, используют вложение операторов if друг в друга. Например, если требуется выполнить один вариант когда, когда некая переменная x меньше нуля, другой — если x равна 0, и третий — если x больше нуля, то синтаксис операторов может быть следующим:

if x else if x = 0 then else 0>;

В данном случае использован вложенный оператор if, который выполняется в случае, когда переменная x не меньше 0. Он проверяет, не является ли значением x число 0, и если нет, то, учитывая, что x явно не меньше, чем 0 (это условие к моменту выполнения вложенного оператора if уже проверено внешним, т.е. первым в данном выражении оператором if), значит значение x больше 0.

Оператор выбора case

Условный оператор удобен в тех случаях, когда необходимо проверить 1-2-3 варианта. При большем числе получается слишком громоздкая и неудобная для восприятия конструкция из множества вложенных инструкций. Скажем, если требуется проверить 5 значений переменной x, то получим такую конструкцию:

if x = 1 then ; else if x = 2 then ; else if x = 3 then ; else if x = 4 then ; else if x = 5 then ;

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

case [выражение-селектор] of : ; : ; . : ; [else ;] end

Единственным ограничением семафора, в сравнении с условным оператором, является то, что в качестве селектора могут выступать лишь данные порядкового типа, скажем, целым числом или же символом. Впрочем, для подавляющего числа случаев этого достаточно. Например, приведенный выше вариант кода с 4 вложенными условными операторами, при помощи case можно оформить так:

case x of 1: ; 2: ; 3: ; 4: ; 5: ; end;

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

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

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

Листинг 4.1. Использование оператора case

var month: integer; season: string; . case month of 1,2,12: season := «зима»; 3..5: season := «весна»; 6..8: season := «лето»; 9..11: season := «осень»; else season := «других не знаем!»; end;

В данном случае, если переменная month имеет значения 1, 2 или 12, то переменной season присваивается значение «зима», если же значение переменной month окажется в диапазоне от 3 до 5 (включительно), то season получит значение «весна», и т.д.

Оператор цикла for

Для написания практически любой программы, помимо операторов условия, требуются операторы цикла, и в Object Pascal, они, разумеется, есть. Прежде всего, это оператор цикла с параметром — for. Такой тип цикла обычно применяют в тех случаях, когда количество возможных повторов известно заранее. Он имеет 2 варианта написания: один — для цикла с приращением, и другой — для цикла с уменьшением:

for := to do ; for := downto do ;

В первом случае (с использованием цикла for-to) при каждом проходе цикла, называемом итерацией, значение параметра увеличивается на 1, а во втором (for-downto) — уменьшается на 1. При этом в качестве начального значения используется «выражение 1», а в качестве конечного — «выражение 2». Разумеется, если для цикла to значение первого выражения изначально будет больше значения второго, или наоборот, меньше (для цикла downto), то цикл не будет выполнен ни разу. Практическое применение циклов крайне разнообразно. Если привести наиболее общий пример из программирования, то цикл — идеальный способ заполнения массива. Например, если требуется организовать цикл для заполнения массива из 10 числовых значений последовательно возрастающими числами, то можно записать:

for i := 0 to 9 do MyArray[i]=i;

В данном случае элементам массива MyArray последовательно назначаются значения от 0 до 9.

ПРИМЕЧАНИЕ
Сами массивы будут рассмотрены несколько позже, в главе, посвященной структурным типам данных.

Теперь рассмотрим цикл for с отрицательным приращением на примере вычисления математического факториала (последовательное произведение всех целых чисел от 1 до самого числа). Для этого нам понадобится следующий цикл:

var num, rez: integer; . rez := 1; for num := num downto 1 do rez := rez * num;

Здесь нам потребовалась небольшая подготовительная работа: определена переменная rez, в которой будет храниться вычисляемое значение, и ей присвоено значение 1. В качестве числа, для которого вычисляется факториал, выступает переменная num, она же используется для самого цикла в качестве счетчика. Поскольку нам надо будет прекратить выполнение цикла, после того, как счетчик (num) достигнет значения 1, то именно это значение и указано в качестве конечного условия.

В итоге, если переменной num присвоить значение 5, то после прохождения цикла переменная rez получит значение 120. Хотя в результате работы такого цикла получится выполнение как бы наоборот (т.е. не вместо 1*2*3*4*5, на самом деле выполняется 5*4*3*2*1), это никак не помешает получить верный результат.

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

Листинг 4.2. Вложенные циклы и форматирование кода

for x := 5 to 10 do begin z := x; for y := 10 to 20 do begin z := z + x * y; writeln(z); end; // конец вложенного цикла writeln(x); end; // конец внешнего цикла

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

Операторы циклов while и repeat

Помимо классического цикла с параметром, в Object Pascal предусмотрено еще 2 вида циклов — с предусловием и с постусловием. В качестве цикла с предусловием выступает оператор while. Он имеет следующий синтаксис:

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

while false do ; В то же время, при помощи оператора while удобно делать бесконечный цикл. В бесконечных циклах весь контроль возлагается на операторы, помещаемые в тело цикла: while true do begin end;

ПРИМЕЧАНИЕ
Очевидно, что цикл с условием, которое изначально истинно и никак не изменяется, будет выполняться вечно. Таким образом, в теле цикла следует предусмотреть возможность его прерывания иным способом.

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

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

repeat x := x + 1; y := x * 2; until y

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

Операторы break и continue

Мы уже поднимали вопрос бесконечного цикла и возможного зацикливания программы, чреватого ее зависанием. Чтобы иметь возможность обработки подобных ситуаций, а так же сделать сами циклы более гибкими, используют специальные операторы — break и continue. Оператор break позволяет завершить цикл досрочно, а оператор continue — выполнить только часть операторов в теле цикла, перейдя к его следующей итерации.

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

while true do begin a := b * c; if a > 1000 then break; b := b + 1; // в случае если a > 1000, эта строка выполнена не будет end; Еще одним полезным применением досрочного выхода является его использования в качестве дополнительного параметра. Например, если нам нужен цикл, который должен прерваться по 1 из 2 условий, то для второй проверки мы можем использовать условный оператор if совместно с break: repeat i := i + 1; if i > 100 then break; y := y — 1; until y

Здесь мы определили цикл, который будет завершен либо после того, как значение переменной y достигнет 50 (что задано в самом условии цикла), либо если значение переменно x превысит указанное в условии if значение 100 — здесь как раз будет задействован оператор break.

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

for i := 1 to 100 do begin if 100 mod i <> 0 then continue; writeln(i); end;

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

Операторы в действии

Таким образом, мы рассмотрели практически все операторы языка Object Pascal, включая 3 типа стандартных циклов. Еще один цикл — for-in, появившийся в Delphi 2005, является частным случаем цикла for-to и позволяет без лишних усилий создавать циклы для данных порядкового типа. Тем не менее, останавливаться на возможностях языка, появившихся после Delphi 7, мы здесь не будем. Рассмотрим лучше практическое применение изученных операторов для реализации алгоритмов, для чего вновь обратимся к игре «угадай число».

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

  • Цикл while, выполняющийся до тех пор, пока число не угадано
  • Два условных оператора if, которые будет проверять, не является ли ответ большим или меньшим, и выводить соответствующую подсказку

Помимо них, нам потребуются несколько стандартных функций Object Pascal — для вывода информационных сообщений, для ввода пользователем значений, а так же для «загадывания» числа. Ввод и вывод в консольных программах осуществляется при помощи функций read и write, соответственно. А для генерации псевдослучайных чисел используют процедуру randomize и функцию random.

ПРИМЕЧАНИЕ
Несколько позже мы подробно ознакомимся с тем, что такое процедуры и функции, и чем они различаются. Пока же достаточно просто принять к сведению, что перечисленные здесь функции будут делать в данном случае.

Итак, для начала запустите Delphi и создайте новое приложение командной строки (File New Other New/Console Application). После того, как Delphi создаст новый проект, сразу сохраните его под каким-либо осмысленным именем, попутно выбрав для него подходящее место на диске. Назовем эту программу «Ugadaika» и помести ее в одноименный каталог на диске C:.

Теперь можно приступать к написанию кода. Поскольку программа должна начинаться с деклараций переменных, то с них и начнем. Нам понадобятся 2 переменных: одна — для хранения загаданного числа, и вторая — для получения ответа пользователя. Назовем их a и b и поместим объявление перед ключевым словом begin. Таким образом, в самом начале работы программа примет такой вид, как показано на примере листинга 4.3.

Листинг 4.3. Программа «угадай-ка» в самом начале разработки

program ugadaika; <$APPTYPE CONSOLE>uses SysUtils; var a,b: integer; begin end.

Теперь можно приступать к написанию основного кода, который, как мы знаем, должен располагаться между begin и end. Начинаться он должен с загадывания числа. Для этого поместим в начало программы (начиная со строки, следующей за begin), следующий код:

randomize; // инициализация генератора псевдослучайных чисел a := random(100)+1; // присваивание переменной a значения от 1 до 100

Далее следует подготовиться к циклу отгадывания, для чего надо, во-первых, установить переменную b в заведомо неподходящее значение (скажем, в 0), а во-вторых — вывести пользователю сообщение, в котором пояснить, чего ему надо делать:

b:=0; write(Input a number between 1 to 100 and hit Enter);

Здесь мы использовали английские символы по той причине, что кодовые номера символов кириллицы для DOS и Windows различаются. Соответственно, чтобы опустить здесь процедуры перекодировки символов, мы пошли по пути наименьшего сопротивления и ограничились латиницей.

Следующим этапом будет создание самого цикла. Мы уже определили условие его выполнения — до тех пор, пока число не отгадано, т.е. пока a не равно b. Соответственно, выглядеть он будет так:

Кроме того, поскольку в цикле будет явно больше 1 оператора, сразу определим составной оператор, добавив begin и end. В результате общий вид программы на текущем этапе получится таким, как показано на листинге 4.4.

Листинг 4.4. «Угадай-ка» с основными блоками

program ugadaika; <$APPTYPE CONSOLE>uses SysUtils; var a,b: integer; begin randomize; a := random(100)+1; b := 0; write(Input a number between 1 to 100 and hit Enter); while (a<>b) do begin end; end.

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

Использованные здесь символы #13 (возврат каретки) и #10 (новая строка) переносят точку ввода на одну строку вниз для лучшего эстетического восприятия. Теперь дадим пользователю возможность ввести свой вариант ответа, воспользовавшись функцией read:

read(b); // введенное число будет помещено в переменную b

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

if (b>a) then write(Too much!);

Теперь составим условие для противоположного случая:

Вот, в общем-то, и все! Остается после завершения цикла предусмотреть вывод сообщения о том, что число отгадано, для чего вновь воспользуемся функцией write, а заодно — функцией sleep, чтобы предотвратить преждевременное закрытие окна:

write(Cool! You win!); sleep(2000); // пауза в 2 секунды

В итоге мы получим вполне работоспособную программу, полный исходный код которой приведен в листинге 4.5, а на CD он находится в Demo\Part1\Ugadaika.

Листинг 4.5. Полный исходный код игры

program ugadaika; <$APPTYPE CONSOLE>uses SysUtils; var a,b: integer; begin randomize; a := random(100)+1; b := 0; write(Input a number between 1 to 100 and hit Enter); while (a a) then write(Too much!); if (b

Then — Ключевое слово Delphi

Прежде чем перейдем к дальнейшему описанию языка Delphi, формально опреде-
лим несколько терминов. Во-первых, это слово «идентификатор». Идентификатор —
это строка символов, используемая для именования некоторого элемента программы.
Это может быть переменная, запись, функция, процедура или конструкция более вы-
сокого уровня, например сама программа.
Идентификатор может иметь любую длину, однако в языке Delphi только первые
его 255 символов являются значимыми (что более чем достаточно!). Идентификатор
должен начинаться с буквы или символа подчеркивания (_) и не может содержать
пробелов. После первого символа идентификатора можно использовать буквы, цифры
и символы подчеркивания. Как и в зарезервированных словах, в идентификаторах
можно использовать как строчные, так и прописные буквы (компилятор их не разли-
чает). Приведенные ниже идентификаторы означают одно и то же.

CalculateValue
calculateValue
calculatevalue
CALCULATEVALUE
Ключевые слова не могут быть идентификаторами.
Далее рассмотрим лексемы. Это минимальные значимые единицы текста в про-
грамме. Они представлены такими категориями, как специальные символы, иденти-
фикаторы, метки, числа и строковые константы.
Программа, написанная на языке Delphi, состоит из лексем и разделителей, при-
чем разделитель представляет собой пробел или комментарий. Две соседних лексемы,
если они представляют собой зарезервированное слово, идентификатор, метку или
число, должны быть отделены друг от друга одним или несколькими разделителями.
В Delphi используются следующие подмножества набора символов кода ASCII.
• Буквы английского алфавита от А до Z и от а до z.
• Цифры — арабские цифры от 0 до 9.
• Шестнадцатеричные цифры — арабские цифры от 0 до 9, буквы от А до F и бу-
квы от а до f.
• Пробелы — символ пробела ($32) и все управляющие символы кода ASCII ($0-$31),
включая символ конца строки или символ возврата каретки ($13). Это шестна-
дцатеричные числа, так как перед ними стоит символ доллара «$».
Теперь определим смысл слова «выражение». Это фрагмент языка программирова-
ния, представляющий способ вычисления некоторого значения.
И наконец, определим смысл слов «операнд» и «оператор».
Операнд — часть выражения, над которым производятся операции. Например,
в выражении, присваивающем А сумму в и с (А := В+С;), А, в, с являются операн-
дами, а над значениями, представленными идентификаторами А й в , производится
операция суммирования. Идентификатор — это строка символов, используемая для именования некоторого
элемента программы.
Лексемы — это минимальные значимые единицы текста в программе.
Выражение — это фрагмент языка программирования, представляющий способ вы-
числения некоторого значения.
Операнд — часть выражения, над которым производятся операции.
Оператор — действие, которое может быть выполнено над одним или несколькими
операндами.
Оператор — действие, которое может быть выполнено над одним или несколькими
операндами. Если обратиться к вышеприведенному примеру, то оператором является
знак плюс (+). Хотя в некоторых случаях оператором можно назвать целое выражение,
заканчивающееся точкой с запятой. Более правильно такие операторы надо называть
структурированными операторами. Например, выражение
while i:=0 to 10 do x := i ;
можно назвать оператором, так как здесь выполняется операция цикла над пере-
менной X.
Теперь можно переходить непосредственно к ключевым словам. Обычно ключевые
слова пишутся строчными буквами, но Delphi безразличен к регистру клавиатуры, по-
этому можно использовать в своей программе как строчные (нижний регистр), так
и прописные (верхний регистр) буквы. Я рекомендую использовать какой-то один
стиль написания, например, тот, к которому вы уже привыкли. Но если вы только на-
чинаете программировать, то лучше использовать общепринятые правила и писать
ключевые слова строчными буквами. В табл. 3.1 приведен перечень всех ключевых
слов с кратким комментарием.
Таблица 3.1. Ключевые слова
Ключевое слово Комментарий
and Булев оператор И
array Массив
as Используется при проверке соответствия типов, определяет объект как операнд
asm Используется для выделения ассемблерного кода
begin Начало блока
case Оператор выбора. Используется при выборе из многих вариантов
class Определяет тип «класс»
const Определяет константы, т.е. неизменяемые переменные. Однако в Delphi есть
режим, допускающий изменение констант в теле программы
constructor Специальный метод класса, необходимый для создания и инициализации
экземпляра класса (объекта)
destructor Специальный метод класса, необходимый для разрушения объекта
d i s p i n t e r f a c e Определяет тип интерфейса
div Целочисленное деление
do Определяет начало исполнимой части в операторах цикла, конструкции
t r y . . . except и в операторе w i t h
downto Определяет направление итерации в операторе f o r
else Используется в операторах выбора case, условном операторе i f и в операторе
проверки исключений t r y . . .except
end
except
e x p o r t s
f i l e
f i n a l i z a t i o n
f i n a l l y
for
f u n c t i o n
goto
i f
implementation
i n
i n h e r i t e d
i n i t i a l i z a t i o n
i n l i n e
i n t e r f a c e
i s
l a b e l
l i b r a r y
mod
n i l
not
o b j e c t
of
or
out
Обычно используется совместно с ключевым словом begin и отмечает конец
блока. Также ставится в конце описания типа, например класса или записи
Используется в операторе проверки исключений t r y . . . except
Определяет список экспортируемых процедур, функций и переменных
Устанавливает тип переменной как файл. Используется при работе с файлами
Определяет начало раздела, который в программе всегда выполняется
последним
Используется в операторе проверки исключений t r y . . . f i n a l l y
Используется в операторах цикла f o r . . . to и f o r . . .downto
Используется при объявлении функций
Переход на метку
Используется в операторах выбора i f . . . then и i f . . . then. . .else
Определяет раздел реализации, в котором находятся описания процедур,
функций, методов и коды разрабатываемой программы
После этого ключевого слова может указываться путь к необходимому модулю.
Также используется при работе с множествами
Дословно можно перевести как «унаследованный». Используется при работе
с классами, поддерживая возможности полиморфизма
Определяет раздел инициализации, который всегда располагается перед
разделом f i n a l i z a t i o n . Если раздела f i n a l i z a t i o n нет, то раздел
инициализации находится перед завершением программы. Выполняется сразу
после запуска программы, перед всеми другими операторами. Обычно
используется для инициализации переменных
Используется при работе с ассемблерным кодом. Устаревшее ключевое слово
к применению не рекомендуется
Определяет тип интерфейса. Используется при опережающем объявлении
интерфейса
Используется при проверке типов
Метка. Используется совместно с ключевым словом goto. Может быть
выражена любым идентификатором или числом от 0 до 9999
Директива-напоминание или рекомендательная директива. Используется
наравне с директивами p l a t f o rm и deprecated для напоминания об
особенностях стандартных типов, методов или модулей. Во время компиляции
вызывает появление предупреждающего сообщения
Остаток от деления целых чисел
Специальная константа, которая может быть присвоена любому указателю,
после чего считается, что указатель не ссылается ни на что
Булев оператор отрицания
Используется как альтернатива слову class. Сохранено в языке для
совместимости со старыми версиями. Не рекомендуется к использованию
Используется во многих операторах как связующее ключевое слово
Булев оператор ИЛИ
Используется при объявлении параметров процедуры, функции или метода.
Предупреждает о том, что данный параметр используется только для
выдачи значений
packed
p r o c e d u r e
program
p r o p e r t y
r a i s e
r e c o r d
r e p e a t
r e s o u r c e s t r i n g
s e a l e d
set
shl
s h r
s t r i n g
then
t h r e a d v a r
t o
t r y
type
u n i t
u n t i l
uses
var
while
w i t h
xor
Используется для более плотного размещения данных в структурированных
типах (массивы, множества, записи, файлы, классы)
Используется при объявлении процедур
Определяет имя программы, которое должно быть выражено
идентификатором
Используется при объявлении свойств
Используется при генерации исключений
Определяет тип записи
Используется в операторе цикла repeat. . . u n t i l
Определяет раздел объявления ресурсов
Используется при объявлении класса, запрещая наследование данного класса
Ключевое слово для объявления множества
Логический оператор сдвига влево
Логический оператор сдвига вправо
Используется при объявлении строковых типов
Используется в операторах i f . . . then и i f . . . t h e n . . .else
Используется при разработке многопоточных приложений
Используется в операторе f o r . . . t o
Используется в операторе проверки исключений t r y . . . f i n a l l y ,
t r y . . .except и в операторе выбора case
Определяет раздел объявления типов
Модуль. Обычно это функционально законченный фрагмент программы,
сохраняемый в файле с таким же именем
Используется в операторе repeat. . . u n t i l
Определяет раздел подключаемых модулей
Определяет раздел переменных
Используется в операторе w h i l e . . . do
Используется для определения идентификатора, который всегда записывается
с другими идентификаторами. Код получается более компактным и понятным
Булев оператор Исключающее ИЛИ
Есть еще несколько ключевых слов, о которых мы поговорим при изучении объектно-
ориентированного программирования и которые могут использоваться как директивы.
Именно эти ключевые слова выделяются жирным шрифтом в редакторе кода, хотя
кое-что может вызвать недоумение: почему, например, слово Break, которое в других
языках программирования является ключевым, в редакторе кодов не подсвечивается?
В Delphi это не ключевое слово, а процедура, и для нее существует отдельное описа-
ние в библиотеке. А процедура write не описана в библиотеках, так как ее код встро-
ен в компилятор. Сейчас мы не будем разбираться в этих тонкостях, а только отме-
тим, что все ключевые слова обычно пишутся строчными буквами, а процедуры
обычно начинаются с прописной буквы.
Написание идентификаторов также можно сделать нагляднее, если использовать слова,
отражающие назначение идентификатора, и начинать каждое слово с прописной буквы.
Например, идентификатор для счетчика символов можно написать так: SymbolCounter. Здесь слова использованы полностью, а разделение достигается за счет того, что второе
слово начинается с большой буквы. Каждый, кто будет читать программу, где использо-
ваны подобные идентификаторы, сможет понять ее без дополнительных комментариев.
Используйте это правило, и ваши программы станут понятнее и для вас самих. (К сожа-
лению, все идентификаторы должны писаться только английскими буквами, поэтому
учите английский, в настоящее время это язык общения программистов.)

If then else в Delphi

Операторы If Then Else (Условия, условные операторы в Delphi)

Чтобы понять, что означает условный оператор If и вся конструкция If then else, ее просто нужно перевести на русский язык.

Ifthen… else…, — это тоже самое, если бы мы сказали по русски:

Если… Тогда… Иначе…,

Оператор If — не зря назван условным, он предназначен для работы с условиями. К программированию на Delphi это имеет следующее отношение…

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

если a<>b тогда c=d+e иначе c=d*e ,

Тут как раз к нам на помощь и приходит конструкция, If then else, — призванная реализовать нашу задумку.

Блог GunSmoker-а

. when altering one’s mind becomes as easy as programming a computer, what does it mean to be human.

22 декабря 2008 г.

Новое ключевое слово static в Delphi

Недавно я переводил пост Почему методы класса должны быть помечены словом «static», чтобы их можно было использовать в качестве функции обратного вызова? Реймонда Чена. Там я оставил весь код «как есть» — на C++. Здесь я рассмотрю этот вопрос с точки зрения Delphi.

Как известно, в языке есть такие сущности как процедуры/функции и методы. Причём начинающие программисты часто путают эти два понятия.

Функция (в дальнейшем здесь будет также подразумеваться и процедура) — это код. Процедурная переменная — это указатель на код. Например: Метод — это тоже код, но код, связанный с классом. Указатель на метод — это ссылка на код + ссылка на конкретный объект. Например: Когда путают одно с другим компилятор чаще всего показывает такое сообщение: «Incompatible types: regular procedure and method pointer». Чаще всего или забывают писать «of object» в объявлении своих процедурных типов или пытаются передать в функцию (чаще всего как callback — т.е. функцию обратного вызова) метод класса вместо обычной функции (а самым упорным это иногда удаётся).

Что делает эти две сущности такими принципиально несовместимыми? Функция — это просто код. Она не имеет связи с данными, отличными от тех, что передаются в её параметры. Методы класса помимо работы с параметрами (как и обычная функция) ещё могут оперировать с данными объекта (вот оно: «код» vs «код + данные»), например: С функциями такое невозможно — обратите внимание, как вы манипулируете с P3 (он же: Self.P3) в методе. Собственно сам объект (это встроенная переменная Self) неявно передаётся в метод первым параметром. Поэтому, если метод объявлен как function(const P1, P2: Integer): Integer of object — с двумя параметрами, то, на самом деле, он трактуется как функция с тремя параметрами: function(Self: TSomeObj; const P1, P2: Integer): Integer . Именно это различие (на бинарном уровне) делает несовместимыми обычные функции и методы.

Соответственно, указатель на обычную функцию — это просто указатель (pointer), только что типизированный (это я про TDoSomethingFunc) — т.е. 4 байта. А вот указатель на метод — это уже запись или, если будет угодно, два указателя — один на код, второй — на данные, т.е. всего 8 байт.

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

Ещё в Delphi есть классовые методы. Это такие методы, которые можно вызывать не имея на руках объект. В этом случае вместо объекта в неявный параметр Self передаётся информация о классе. Т.е. в классовых методах вы не можете использовать информацию о конкретном объекте (например, читать/писать его поля), но можете использовать информацию о классе — например, вызывать конструктор класса. Также методы класса могут быть виртуальными. Заметим, что сигнатура функции, реализующей метод, всё ещё совпадает с сигнатурой обычного метода: неявный параметр (данные класса вместо Self) + все явные параметры метода.

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

Рассматривая пример с потоком, вот что мы могли бы написать в старых Delphi без поддержки статических классовых методов: Теперь, с введением нового ключевого слова static, появилась возможность писать так: При этом Реймонд говорит о том, что если у Execute сделать модель вызова stdcall, то бинарные сигнатуры параметра CreateThread, методов ThreadProc и Execute совпадут — поэтому, мол, умный компилятор уменьшит код ThreadProc до простого jmp. Увы, но компилятор Delphi не настолько умён — в этом случае он генерирует полный вызов вместе с передачей параметра.

DelphiComponent.ru — бесплатно видеоуроки по Delphi, статьи, исходники

Операторы выбора if в Delphi

Выбор в точке разветвления алгоритма очередного шага программы может быть реализован при помощи инструкций if и саsе.

Инструкция if — позволяет выбрать один из двух возможных вариантов, инструкция case — один из нескольких.Инструкция if Инструкция if позволяет выбрать один из двух возможных вариантов развития программы. Выбор осущестнляется в зависимости от выполнения условия.

В общем виде инструкция if записывается так:

Обратите внимание, что перед else (после end) точка с запятой не ставится.

Выполняется инструкция if следующим образом:

  1. Вычисляется значение условия (условие — выражение логического типа, значение которого может быть равно True или False).
  2. Если условие истинно (значение выражения условие равно True), то выполняются инструкции, следующие за словом then (между begin и end).

На этом выполнение операции if заканчивается, то есть инструкции, следующие за else, не будут выполнены.

Если условие ложно (значение выражения условие равно False), то выполняются инструкции, следующие за словом else (между begin и end).

Например, если переменная t обозначает тип соединения сопротивлений в электрической цепи (t=l соответствует последовательному соединению, t=2 — параллельному), a ri и г2 — величины сопротивлений, то приведенная ниже инструкция if осуществляет выбор формулы, по которой будет выполнен расчет.

Тема: Конструкция IF. THEN. ELSE

Показано с 1 по 1 из 1

Опции темы
Поиск по теме
Отображение
  • Линейный вид
  • Комбинированный вид
  • Древовидный вид

Конструкция IF. THEN. ELSE

З дравствуйте, в этом уроке я познакомлю вас с конструкцией if then else и мы напишем программу проверки логина и пароля! И так, приступим! К онструкцией if then else можно проверять какое-нибудь условие, дословно она переводится так: если то иначе.

К онструкция имеет такой вид:

К стати, после двойного слеша » // » пишется комментарий. Он никак не влияет на код программы, потому что компилятор его игнорирует.
Т еперь я попытаюсь вам объяснить всё на практике. О ткрываем Delphi и создаем новый проект.
Кидаем на форму уже знакомые нам компоненты Button , Label 3 штуки и еще не знакомый Edit 2 штуки (он находится правее от компонента Label).

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

П ереходим в инспектор объектов и изменяем свойства у компонентов по очереди:

  • Label1.Caption = ‘Логин’
  • Label2.Caption = ‘Пароль’
  • Label3.AutoSize = False Выставив значение False у свойства AutoSize, мы запретили автоматически менять размер компоненту
  • Label3.Caption = ‘ ‘ Когда мы стёрли весь текст, размер компонента не изменился
  • Edit1.Text = ‘ ‘
  • Edit2.Text = ‘ ‘
  • Button1.Caption = ‘Авторизоваться’

С ейчас выделяем компонент Label3 и растягиваем его ширину на всю форму:

Н ужно изменить еще одно свойство у компонента Label3 , оно называется Alignment и отвечает за выравнивание текста по центру. Выставляем значение taCenter. Теперь весь текст будет появляться в этом лейбле по центру.

Мы завершили с настройкой формы, теперь создаем обработчик OnClick на нашей кнопке. И так, принцип работы нашей программы: если логин и пароль верны, то оповещаем об этом, иначе — выдаем ошибк у .

Н ачнем с простого — проверка логина:

К омпилируем программу и вводим в наш Edit1 слово admin , нажимаем на кнопку и вуаля — Label3 оповестит о том, что мы авторизованы, теперь напишите что-нибудь другое в Edit1 и нажмите на кнопку. Label3 оповестит, что логин не верный.

И дем дальше — проверяем логин и пароль. Т ак как нужно проверять 2 условия, каждое из условий нужно окружить скобками, а между скобок напишем ключевое слово and:

В ернемся к коду, где использовали ключевое слово and между условиями. У нас там выдается ошибка ‘Логин ИЛИ пароль не верный’, если пользователь ошибся. Давайте сделаем ошибку конкретней, чтобы она сообщала, что именно не верно, логин или пароль? Для этого сотрем нашу не конкретную ошибку и добавим еще 3 конструкции if then . Вместо знака равенства в условии, мы будем использовать знак не равенства <>

К омпилируем и п роверяем!
На последок хочу вам показать еще один компонент, так называемый XPManifest, он находится на вкладке Win32 (самый последний компонент на этой вкладке). XPManifest восстанавливает вид всех компонентов из классического вида в тот, который сейчас используется в системе. Д обавив его на форму, мы увидим прекрасные кнопочки. :)

Программирование на языке Delphi

Глава 2. Основы языка Delphi


Авторы: А.Н. Вальвачев
К.А. Сурков
Д.А. Сурков
Ю.М. Четырько

Опубликовано: 12.11.2005
Исправлено: 10.12.2020
Версия текста: 1.0

В основе среды Delphi лежит одноименный язык программирования — Delphi, ранее известный как Object Pascal. При разработке программы среда Delphi выполняет свою часть работы — создает пользовательский интерфейс согласно вашему дизайну, а вы выполняете свою часть — пишите обработчики событий на языке Delphi. Объем вашей работы зависит от программы: чем сложнее алгоритм, тем тяжелее ваш труд. Необходимо заранее усвоить, что невозможно заставить средство разработки делать всю работу за вас. Некоторые задачи среда Delphi действительно полностью берет на себя, например создание простейшей программы для просмотра базы данных. Однако большинство задач не вписываются в стандартные схемы — вам могут понадобиться специализированные компоненты, которых нет в палитре компонентов, или для задачи может не оказаться готового решения, и вы вынуждены будете решать ее старым дедовским способом — с помощью операторов языка Delphi. Поэтому мы настоятельно рекомендуем вам не игнорировать эту главу, поскольку на практике вы не избежите программирования. Мы решили изложить язык в одной главе, не размазывая его по всей книге, чтобы дать вам фундаментальные знания и обеспечить быстрый доступ к нужной информации при использовании книги в качестве справочника.

2.1. Алфавит


2.1.1. Буквы

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

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

Буквы — это прописные и строчные символы латинского алфавита и символ подчеркивания:

Цифры представлены стандартной арабской формой записи:

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

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

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

2.1.2. Числа

Одно и то же число можно записать самыми разными способами, например:

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

Целые числа состоят только из цифр и знака + или – . Если знак опущен и число не равно 0, то оно рассматривается как положительное, например:

Вещественные числа содержат целую и дробную части, разделенные точкой:

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

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

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

Число, стоящее перед буквой E, называется мантиссой , а число после буквы E — порядком .

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

2.1.3. Слова-идентификаторы

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

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

Правильно Неправильно
RightName Wrong Name
E_mail E–mail
_5inches 5inches

Все идентификаторы подразделяются на зарезервированные слова, стандартные директивы, стандартные идентификаторы и идентификаторы программиста.

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

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

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

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

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

2.1.4. Комментарии

С помощью комментариев вы можете пояснить логику работы своей программы. Комментарий пропускается компилятором и может находиться в любом месте программы. Комментарием является:

2.2. Данные


2.2.1. Понятие типа данных

Программа в процессе выполнения всегда обрабатывает какие-либо данные. Данные могут представлять собой целые и дробные числа, символы, строки, массивы, множества и др. Так как компьютер всего лишь машина, для которой данные — это последовательность нулей и единиц, он должен абсолютно точно «знать», как их интерпретировать. По этой причине все данные в языке Delphi подразделены на типы. Для описания каждого типа данных существует свой стандартный идентификатор: для целых — Integer, для дробных — Real, для строк — string и т.д. Программист может образовывать собственные типы данных и давать им произвольные имена (о том, как это делается, мы поговорим чуть позже).

Тип данных показывает, какие значения принимают данные и какие операции можно с ними выполнять. Каждому типу данных соответствует определенный объем памяти, который требуется для размещения данных. Например, в языке Delphi существует тип данных Byte. Данные этого типа принимают значения в целочисленном диапазоне от 0 до 255, могут участвовать в операциях сложения, вычитания, умножения, деления, и занимают 1 байт памяти.

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

  • простые типы данных. Они в свою очередь подразделяются на порядковые и вещественные типы данных. К порядковым типам относятся целочисленные, символьные, булевские, перечисляемые и интервальные типы данных;
  • временной тип данных. Служит для представления значений даты и времени;
  • строковые типы данных. Служат для представления последовательностей из символов, например текста;
  • составные типы данных (в некоторых источниках — структурированные типы данных). Формируются на основе всех остальных типов. К ним относятся массивы, множества, записи, файлы, классы и ссылки на классы;
  • процедурные типы данных. Позволяют манипулировать процедурами и функциями как данными программы;
  • указательные типы данных. Данные этих типов хранят адреса других данных, с их помощью организуются различные динамические структуры: списки, деревья и т.д.;
  • тип данных с непостоянным типом значений. Служит для представления значений, тип которых заранее неизвестен; с его помощью легко организуется работа со списком разнотипных значений;

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

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

2.2.2. Константы

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

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

Значение константы можно задавать и выражением. Эту возможность удобно использовать для комплексного представления какого-либо понятия. Например, временной промежуток, равный одному месяцу, можно задать так:

Очевидно, что, изменив базовую константу SecondsInMinute, можно изменить значение константы SecondsInDay.

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

Такие константы называются типизированными; их основное назначение — объявление константных значений составных типов данных.

2.2.3. Переменные

Переменные в отличие от констант могут неограниченное число раз менять свое значение в процессе работы программы. Если в начале программы некоторая переменная X имела значение 0, то в конце программы X может принять значение 10000. Так бывает, например, при суммировании введенных с клавиатуры чисел.

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

В теле программы переменной можно присвоить значение. Для этого используется составной символ := , например:

Вы можете присвоить значение переменной непосредственно при объявлении:

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

Каждый используемый в программе элемент данных должен быть описан в разделе const или var . Исключение составляют данные, заданные непосредственно значением , например:

2.3. Простые типы данных


2.3.1. Целочисленные типы данных

Целочисленные типы данных применяются для описания целочисленных данных. Для решения различных задач могут потребоваться различные целые числа. В одних задачах счет идет на десятки, в других — на миллионы. Соответственно в языке Delphi имеется несколько целочисленных типов данных, среди которых вы можете выбрать наиболее подходящий для своей задачи (таблица 2.1).

Фундаментальные типы данных:

Тип данных Диапазон значений Объем памяти (байт)
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*
Таблица 2.1. Целочисленные типы данных
ПРИМЕЧАНИЕ

* — количество байт памяти, требуемых для хранения переменных обобщенных типов данных, приведено для 32-разрядных процессоров семейства x86.

Пример описания целочисленных данных:

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

2.3.2. Вещественные типы данных

Вещественные типы данных применяются для описания вещественных данных с плавающей или с фиксированной точкой (таблица 2.2).

Тип данных Диапазон значений Мантисса Объем памяти (байт)
Real 5.0*10 –324 ..1.7*10 308 15–16 8*
Real48 2.9*10 –39 ..1.7*10 38 11–12 6
Single 1.5*10 –45 ..3.4*10 38 7–8 4
Double 5.0*10 –324 ..1.7*10 308 15–16 8
Extended 3.4*10 –4932 ..1.1*10 4932 19–20 10
Comp –9223372036854775808 .. 9223372036854775807 19–20 8
Currency –922337203685477.5808 .. 922337203685477.5807 19–20 8
Таблица 2.2. Вещественные типы данных
ПРИМЕЧАНИЕ

* -количество байт памяти, требуемых для хранения переменных обобщенных типов данных, приведено для 32-разрядных процессоров семейства x86.

Пример описания вещественных данных:

Необходимо отметить, что тип Real является обобщенным типом данных и по отношению к нему справедливо все то, что было сказано о типах Integer и Cardinal.

2.3.3. Символьные типы данных

Символьные типы применяются для описания данных, значением которых является буква, цифра, знак препинания и другие символы. Существуют два фундаментальных символьных типа данных: 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*
Таблица 2.3. Символьные типы данных
ПРИМЕЧАНИЕ

* — Тип данных Char является обобщенным и соответствует типу AnsiChar. Однако следует помнить, что в будущем тип данных Char может стать эквивалентным типу данных WideChar, поэтому не следует полагаться на то, что символ занимает в памяти один байт.

Пример описания переменной символьного типа:

В программе значения переменных и констант символьных типов заключаются в апострофы (не путать с кавычками!), например:

2.3.4. Булевские типы данных

Булевские типы данных названы так в честь Георга Буля (George Boole), одного из авторов формальной логики. Диапазон значений данных булевских типов представлен двумя предопределенными константами: True — истина и False — ложь (таблица 2.4).

Тип данных Диапазон значений Объем памяти (байт)
Boolean False (0), True (1) 1
ByteBool False (0), True (не равно 0) 1
WordBool False (0), True (не равно 0) 2
LongBool False (0), True (не равно 0) 4
Таблица 2.4. Булевские типы данных

Пример описания булевских данных:

Булевские типы данных широко применяются в логических выражениях и в выражениях отношения. Переменные типа Boolean используются для хранения результатов логических выражений и могут принимать только два значения: False и True (стандартные идентификаторы). Булевские типы данных ByteBool, WordBool и LongBool введены в язык Delphi специально для совместимости с другими языками, в частности с языками C и C++. Все булевские типы данных совместимы друг с другом и могут одновременно использоваться в одном выражении.

2.3.5. Определение новых типов данных

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

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

Синтаксическая конструкция type позволяет создавать новые порядковые типы: перечисляемые типы и интервальные типы .

2.3.6. Перечисляемые типы данных

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

На базе типа TDirection можно объявить переменную Direction и присвоить ей значение:

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

2.3.7. Интервальные типы данных

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

В операциях с переменными интервального типа данных компилятор генерирует код проверки на принадлежность диапазону, поэтому последний оператор вызовет ошибку. Это очень удобно при отладке, но иногда отрицательно сказывается на скорости работы программы. Для отключения контроля диапазона откройте окно Project Options , выберите страницу Compiler и снимите пометку пункта Range Checking .

Данные перечисляемых и интервальных типов занимают в памяти 1, 2 или 4 байта в зависимости от диапазона значений типа. Например, если диапазон значений не превышает 256, то элемент данных занимает один байт памяти.

2.3.8. Временной тип данных

Для представления значений даты и времени в среде Delphi существует тип TDateTime. Он объявлен тождественным типу Double. Целая часть элемента данных типа TDateTime соответствует количеству дней, прошедших с полночи 30 декабря 1899 года. Дробная часть элемента данных типа TDateTime соответствует времени дня. Следующие примеры поясняют сказанное:

Значение Дата Время
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

2.3.9. Типы данных со словом type

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

В приведенном выше примере тип данных TFileName является псевдонимом для стандартного типа данных string.

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

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

В примере переменные A и B оказываются несовместимы друг с другом из-за слова type в описании типа TType2. Если же переменные A и B принадлежат простым типам данных, то оператор присваивания будет работать:

2.4. Операции


2.4.1. Выражения

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

X, Y, 2 — операнды; ‘+’, ‘/’ — знаки операций; скобки говорят о том, что сначала выполняется операция сложения, потом — деления.

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

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

2.4.2. Арифметические операции

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

Операция Действие Тип операндов Тип результата
+ Сложение Целый, вещественный Целый, вещественный
Вычитание Целый, вещественный Целый, вещественный
* Умножение Целый, вещественный Целый, вещественный
/ Деление Целый, вещественный Вещественный
div Целочисленное деление Целый Целый
mod Остаток от деления Целый Целый
Таблица 2.5. Арифметические операции

Операции сложения, вычитания и умножения соответствуют аналогичным операциям в математике. В отличие от них операция деления имеет три формы: обычное деление (/), целочисленное деление ( 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
5 mod 2 1
11 mod 4 3
–20 mod 7 –6
–20 mod 7 –6

2.4.3. Операции отношения

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

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

Операция Действие Выражение Результат
= Равно A = B True, если A = B
<> Не равно A <> B True, если A B
Больше A > B True, если A > B
= Больше или равно A >= B True, если A > B или A = B
Таблица 2.6. Операции отношения

Типичные примеры операций отношения:

Выражение Результат
123 = 132 False
123 <> 132 False
17 19 False
7 >= 7 True

2.4.4. Булевские операции

Результатом выполнения логических (булевских) операций является логическое значение True или False (таблица 2.7). Операндами в логическом выражении служат данные типа Boolean.

Операция Действие Выражение A B Результат
not Логическое отрицание not A TrueFalse FalseTrue
and Логическое И A and B TrueTrueFalseFalse TrueFalseTrueFalse TrueFalseFalseFalse
or Логическое ИЛИ A or B TrueTrue FalseFalse TrueFalseTrueFalse TrueTrueTrueFalse
xor Исключающее ИЛИ A xor B TrueTrue FalseFalse TrueFalseTrueFalse FalseTrueTrueFalse
Таблица 2.7. Логические операции

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

Выражение Результат
not (17 > 19) True
(7 shl ) и вправо ( shr ).

Операция Действие Тип операндов Тип результата
not Побитовое отрицание Целый Целый
and Побитовое И Целый Целый
or Побитовое ИЛИ Целый Целый
xor Побитовое исключающее ИЛИ Целый Целый
shl Сдвиг влево Целый Целый
shr Сдвиг вправо Целый Целый
Таблица 2.8. Побитовые операции

Примеры побитовых операций:

Выражение Результат
not $FF00 $00FF
$FF00 or $0FF0 $FFF0
$FF00 and $0FF0 $0F00
$FF00 xor $0FF0 $F0F0
$FF00 shl 4 $F000
$FF00 shr 4 $0FF0

2.4.6. Очередность выполнения операций

При выполнении выражений одни операции выполняются раньше других. Например, в выражении

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

Операция Приоритет Описание
–, not Первый Унарный минус, отрицаиие
*, /, div, mod, and Второй Операции типа умножение
+, –, or, xor Третий Операции типа сложение
=, <>, , = Четвертый Операции отношения
Таблица 2.9. Приоритет операций

Чем выше приоритет (первый — высший), тем раньше операция будет выполнена.

2.5. Консольный ввод-вывод


2.5.1. Консольное приложение

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

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

Итак, давайте последовательно создадим консольное приложение:

1. Запустите среду Delphi, выберите в главном меню команду File | Close All , а затем — команду File | New .

2. Выберите “Console Application” и нажмите “OK” (рисунок 2.1).

Рисунок 2.1. Окно среды Delphi для создания нового проекта

3. В появившемся окне между ключевыми словами BEGIN и END введите следующие строчки (рисунок 2.2):

Рисунок 2.2. Текст простейшей консольной программы в окне редактора кода

4. Скомпилируйте и выполните эту программу, щелкнув на пункте Run | Run главного меню среды Delphi. На экране появится черное окно (рисунок 2.3), в левом верхнем углу которого будет содержаться текст «Press ENTER to exit. » («Нажмите клавишу Enter . «).

Рисунок 2.3. Окно работающей консольной программы

5. Нажмите в этом окне клавишу Enter — консольное приложение завершится.

Теперь, когда есть основа для проверки изучаемого материала, рассмотрим операторы консольного ввода-вывода. К ним относятся Write, Writeln, Read, Readln.

2.5.2. Консольный вывод

Инструкции Write и Writeln служат для вывода чисел, символов, строк и булевских значений на экран. Они имеют следующий формат:

где Y1, Y2. Yn — константы, переменные и результаты выражений. Инструкция Writeln аналогична Write, но после своего выполнения переводит курсор в начало следующей строки.

Если инструкции Write и Writeln записаны без параметров:

то это вызывает пропуск на экране соответственно одной позиции и одной строки.

2.5.3. Консольный ввод

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

где X1, X2, . Xn — переменные, для которых осуществляется ввод значений. Пример:

Если одна инструкция вводит несколько значений:

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

Если вводится одно значение:

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

Инструкция Readln отличается от Read только одним свойством: каждое выполнение инструкции Readln переводит курсор в начало новой строки, а после выполнения Read курсор остается в той же строке, где и был (потренеруйтесь — и вы быстро поймете разницу).

В простейшем случа