назад

Глава 6. Выражения

Выражения состоят из операций и операндов. Большинство операций в языке Паскаль являются бинарными, то есть содержат два операнда. Остальные операции являются унарными и содержат только один операнд. В бинарных операциях используется обычное алгебраическое представление, например: a+b. В унарных операциях операция всегда предшествует операнду, например: -b.

В более сложных выражениях порядок, в котором выполняются операции, соответствует приоритету операций (см. Таблицу 6.1).

Таблица 6.1. Старшинство операций

Для определении старшинства операций имеется три основных правила:

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

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

Синтаксис выражений

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

Множитель имеет следующий синтаксис:

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

Адресный множитель вычисляет адрес переменной, процедуры, функции или метода. См. раздел "Операция @".

Беззнаковая константа имеет следующий синтаксис:

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

    Х                                    { ссылка на переменную }

    @Х                                { указатель на переменную }

    15                                    { константа без знака }

    (Х+Y+Z)                                      { подвыражение }

    SIN(Х/2)                                    { вызов функции }

    ['0..''9','А'..'Z']                   { описатель множества }

    not Done                   { отрицание булевской переменной }

    сhar(Digit+48)                            { назначение типа }

Термы используются в операциях умножения на множитель:

Приведем несколько примеров термов:

     Х * Y

     Z / (1 - Z)

     Done or Error

     (Х <= Y) and (Y < Z)

В простых выражениях к термам применяются операции сложения и присваивания знака:

Приведем несколько примеров простых выражений:

     Х + Y

     -Х

     Hue1 + Hue2

     I * J + 1

В выражениях к простым выражениям применяются операции отношения.

Приведем некоторые примеры выражений:

     Х = 1.5

     Done <> Error

     (I < J) = (J < К)

     C in Huel

Операции

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

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

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

Таблица 6.2. Бинарные арифметические операции

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

Таблица 6.3. Унарные арифметические операции

Любая операция, включающая операнд, тип которого является подмножеством порядкового типа, обрабатывается также, как если бы он был порядкового типа.

Если оба операнда в операциях +, -, *, div или моd являются операндами целого типа, то тип результата будет таким же, как общий тип обоих операндов. (Определение общего типа см. в разделе "Целый тип" в Главе 3).

Если один или более операндов в операциях +, -, или * имеют вещественный тип, то тип результата будет вещественным, если использована директива компилятора {$N-}, или типом с повышенной точностью при использовании директивы компилятора {$N+}.

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

Значение выражения х/у всегда будет вещественного типа (real) или с повышенной точностью (extended), независимо от типов операндов. Если у равно 0, то результат будет ошибочным.

Значение выражение i div j представляет собой математическое частное от i/j, округленное в меньшую сторону до значения целого типа. Если j равно 0, результат будет ошибочным.

Операция mod возвращает остаток, полученный путем деления двух ее операндов, то есть:

     i mod j = i - (i div j) * j

Знак результата операции mod будет тем же, что и знак i. Если j равно нулю, то результатом будет ошибка.

Логические операции

Типы логических операций показаны в Таблице 6.4.

Таблица 6.4. Логические операции

Примечание: Операция not является унарной операцией.

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

Если оба операнда в операциях or, and или xor целого типа, то тип результата будет таким же, как тип обоих операндов.

Операции i shl j и i shr j сдвигают значение i влево или вправо на j битов. Тип результата будет таким же, как тип i.

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

Типы операндов и результат для булевских операций показаны в Таблице 6.5.

Таблица 6.5. Булевские операции

Примечание: Операция not является унарной операцией.

Результаты этих операций соответствуют обычной булевой логике. Например, выражение a and b является истинным (принимает значение Тruе) только в том случае, если оба операнда a и b имеют истинное значение (Тruе).

В Borland Pascal поддерживаются две различные модели генерации кода для операций or и and - полное вычисление и вычисление по короткой схеме (частичное вычисление).

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

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

     while (I<=Lenght(S)) and (S[I]<>' ') do

        Inc(I);

     while (P<>nil) and (P^.Value<>5) do

        P:=P^.Next;

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

Схему вычисления можно задавать с помощью директивы компилятора $B. Значением по умолчанию является состояние {$B-} (пока оно не будет изменено с помощью "меню" возможностей компилятора). В этом случае генерируется код с вычислением по короткой схеме. В случае директивы {$B+} генерируется код с полным вычислением.

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

Операция со строками

Типы операндов и результаты для операции со строками показаны в Таблице 6.6.

Таблица 6.6. Операции со строками

Borland Pascal позволяет использовать операцию + для объединения двух строковых операндов. Результатом операции s + t, где s и t имеют строковый тип, символьный тип (Char) или упакованный строковый тип, будет конкатенация s и t. Результат будет совместим с любым строковым типом (но не с символьным Char и не с упакованным строковым типом). Если длина результирующей строки превышает 255 символов, то она усекается до 255 символов.

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

Расширенный синтаксис (разрешенный по директиве компилятора {$X+}) поддерживает несколько операций с указателями на PChar. Для увеличения и уменьшения смещения указателя можно использовать операции + и -. Минус можно также использовать для вычисления расстояния (разности) между двумя символьными указателями. Если P и Q - это значения типа PChar, а I - значение типа Word, то допустимы следующие конструкции:

Таблица 6.7. Допустимые конструкции PChar

Операции P + I и I + P складывает I c адресом, заданным P, создавая указатель, ссылающийся на I символов после P. Операция P - I вычитает I из адреса, заданного P, создавая указатель, ссыла- ющийся на I символов перед P.

Операция P - Q вычитает расстояние между Q (младший адрес) и P (старший адрес), создавая в результате значение типа Word, показывающее число символов между Q и P. Эта операция подразумева- ет, что P и Q ссылаются на один символьный массив. Если два символьный указателя ссылаются на разные массивы, то результат будет не определен.

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

Типы операндов для операций над множествами показаны в Таблице 6.7.

Таблица 6.7. Операции над множествами

Результаты операций соответствуют правилам логики работы с множествами:

1. Порядковое значение c содержится в a+b только тогда, когда оно содержится в a или в b.
2. Порядковое значение c содержится в a-b только тогда, когда оно содержится в a и не содержится в b.
3. Порядковое значение c содержится в a*b только тогда, когда он содержится в обоих множествах a и b.

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

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

Типы операндов и результаты операций отношения приведены в Таблице 6.8.

Таблица 6.8. Операции отношения

Сравнение простых типов

Когда операции =, <>, <, >, >= или <= применяются для операндов простых типов, то это должны быть совместимые типы. Однако, если один операнд имеет вещественный тип, то другой может быть целого типа.

Сравнение строк

Операции отношения =, <>, <, >, >= или <= могут применятся для сравнения строк согласно порядку расширенного набора символов кода ASСII. Любые два значения строковых данных можно сравнить, поскольку все значения строковых данных совместимы.

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

Сравнение упакованных строк

Операции отношения =, <>, <, >, >= или <= могут применятся также для двух упакованных значений строкового типа, если они содержат одинаковое число элементов. Если число элементов равно n, то операция соответствует сравнению двух строк, каждая из которых имеет длину n.

Сравнение указателей

Операции = и <> могут использоваться для сравнения операндов типа указатель. Два указателя равны только в том случае, если они ссылаются на один и тот же объект.

Сравнение символьных указателей

При разрешении по директиве компилятора {$X+} расширенного синтаксиса операции =, <>, <, >, >= или <= могут применятся к значениям PChar. Заметим, однако, что эти операции отношения предполагают, что два сравниваемые указателя ссылаются на один и тот же символьный массив.. По этой причине в сравнении участвуют только смещения двух значений-указателей. Если указатели ссылаются на разные символьные массивы, результат будет не определен.

Сравнение множеств

Если операндами являются множества a и b, то при их сравнении получаются следующие результаты:

1. Выражение a = b истинно (= True) только когда a и b содержат одни и те же элементы, в противном случае a<>b.
2. Выражение a = b истинно, когда каждый элемент множества а является также элементом множества b.
3. Выражение a = b истинно, когда каждый элемент множества b является также элементом множества a.

Проверка на принадлежность к множеству

Операция in возвращает истинное значение (True), когда значение элемента порядкового типа является элементом операнда множественного типа, в противном случае он возвращает значение False.

Операция @

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

Таблица 6.9. Операция создания указателя

Операция @ возвращает адрес операнда, то есть строит значение-указатель, ссылающееся на этот операнд.

Использование операции @ для переменной

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

     type

       TwoChar = array[0..1] of char;

     var

       Int: integer;

       TwoCharPtr: ^TwoChar;

тогда оператор:

     TwoCharPtr := @Int;

приводит к тому, что TwoCharPtr для получения ссылки на TwoCharPtr^ становится повторной интерпретацией значения Int, как если бы оно было символьным массивом array[0..1].

Тип получаемого в результате указатель управляется директивой компилятора $T: в состоянии {$T-} (по умолчанию) типом результата будет Pointer. Другими словами, результат ом является нетипизированный указатель, совместимый со всеми другими типами указателей. В состоянии {$T+} типом результата будет ^T, где T - тип ссылки на переменную. То есть тип результата будет совместим со всеми другими указателями на тип этой переменной.

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

Использование операции @ для процедуры или функции или метода

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

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

Вызовы функции

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

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

Примечание: См. выше разделы "Активизация методов", "Активизация уточненных методов" и "Процедурные типы".

Приведем некоторые примеры вызовов функций:

     Sum(A,63)

     Maximum(147,J)

     Sin(X+Y)

     Eof(F)

     Volume(Radius, Height)

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

Описатели множества

Описатель множества определяет значения множественного типа и получается путем записи выражений, заключенных в квадратные скобки ([]). Каждое выражение определяет значение множества.

Обозначение [ ] означает пустое множество, тип которого совместим по присваиванию с типом любого множества. Любая группа элементов, описанная, как х..у, объявляет элементами множества все значения в диапазоне х..у. Если х больше, чем у, то х..у не описывает никаких элементов и [x..y] обозначает пустое множество.

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

Приведем некоторые примеры описателей множеств:

     [red, C, green]

     [1,5,10..K mod 12, 13, 23]

     ['A'..'Z', 'a'..'z', Chr(Digit+48)]

Приведение типа значений

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

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

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

Некоторые примеры приведения типа значений включают в себя:

     Intereg('A')

     Char(48)

     Boolean(0)

     Color(2)

     IntPtr(@Buffer)

     BytePtr(Ptr($40,$49))

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

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

     type

        IntFunc = function: Integer;

     var

        F: IntFunc;

        N: Integer;

     function ReadInt: Integer; far;

     var

        I: Integer;

     begin

        Read(I);

        ReadInt := I;

     end;

     begin

        F := ReadInt;      { присваивание процедурного значения }

        N := ReadInt;      { присваивание результата функции }

     end.

Первый оператор основной программы присваивает процедурное значение (адрес процедуры) ReadInt процедурной переменной F, второй оператор вызывает ReadInt и присваивает N возвращаемое значение. Различие между получением процедурного значения или вызовом функции осуществляется по типу переменной, которой присваивается значение (F или N).

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

     if F = ReadInt then

       WriteLn('Equal');

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

     if @F = @ReadInt then

       WriteLn('Equal');

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

Операция @ часто используется при присваивании процедурной переменной нетипизированного значения-указателя. Например, определенная в Windows (в модуле WinProcs) функция GetProcAddress возвращает адрес экспортируемой функции в DLL как нетипизированной значение-указатель. С помощью операции @ вызов GetProcAddress можно присвоить процедурной переменной:

     type

       TStrComp = function(Str1, Str2: PChar): Integer;

     var

       StrComp: TStrComp:

         .

         .

         .

     begin

      .

      .

      .

      @StrComp := GetProcAddress(KernelHandle, 'Lstrcmpi');

          .

          .

          .

     end.

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