uint64
uint64
BigInteger
single
real
int64
int64
int64
int64
int64
int64
uint64
int64
uint64
BigInteger
single
real
uint64
uint64
uint64
uint64
uint64
uint64
uint64
uint64
uint64
BigInteger
single
real
BigInteger
BigInteger
BigInteger
BigInteger
BigInteger
BigInteger
BigInteger
BigInteger
BigInteger
BigInteger
-
-
single
single
single
single
single
single
single
single
single
-
single
real
real
real
real
real
real
real
real
real
real
-
real
real
То есть, если операнды - целые, то результатом является самый короткий целый тип, требуемый для представления всех получаемых значений.
При выполнении бинарной операции с uint64 и знаковым целым результирующим типом будет uint64, при этом может произойти переполнение, не вызывающее исключения.
Для операции / данная таблица исправляется следующим образом: результат деления любого целого на целое имеет тип real.
Для операций div и mod выполняются эти же правила, но операнды могут быть только целыми. Правила вычисления операций div и mod - следующие:
x div y - результат целочисленного деления x на y. Точнее, x div y = x / y, округленное до ближайшего целого по направлению к 0;
x mod y - остаток от целочисленного деления x на y. Точнее, x mod y = x - (x div y) * y.
Унарная арифметическая операция + для любого целого типа возвращает этот тип. Унарная арифметическая операция - возвращает для целых типов, меньших или равных integer, значение типа integer, для longword и int64 - значение типа int64, к uint64 унарная операция - не применима, для типов single и real - соответственно типы single и real. То есть так же результатом является самый короткий тип, требуемый для представления всех получаемых значений.
Логические операции
К логическим относятся бинарные операции and, or и xor, а также унарная операция not, имеющие операнды типа boolean и возвращающие значение типа boolean. Эти операции подчиняются стандартным правилам логики: a and b истинно только тогда, когда истинны a и b, a or b истинно только тогда, когда истинно либо a, либо b, a xor b истинно только тогда, когда только одно из a и b истинно, not a истинно только тогда, когда a ложно.
Выражения с and и or вычисляются по короткой схеме:
в выражении x and y если x ложно, то все выражение ложно, и y не вычисляется;
в выражении x or y если x истинно, то все выражение истинно, и y не вычисляется.
Побитовые операции
К побитовым относятся бинарные операции and, or, not, xor, shl, shr. Они производят побитовые манипуляции с операндами целого типа. Результирующий тип для and, or, xor будет наименьшим целым, включающим все возможные значения обоих типов операндов. Для shl, shr результирующий тип совпадает с типом левого операнда, для not - с типом операнда.
Побитовые операции осуществляются следующим образом: с каждым битом (0 принимается за False, 1 - за True) производится соответствующая логическая операция. Например:
00010101 and 00011001 = 00010001
00010101 or 00011001 = 00011101
00010101 xor 00011001 = 00001100
not 00010101 = 11101010
(операнды и результат представлены в двоичной форме).
Операциии shl и shr имеют вид:
a shl n
a shr n
где n - целое положительное число, a - целое число.
a shl n представляет собой целое положительное, полученное из двоичного представления числа a сдвигом влево на n позиций. Добавляемые справа позиции заполняются нулями.
a shr n представляет собой целое положительное, полученное из двоичного представления числа a сдвигом вправо на n позиций.
Например:
3 shl 2 = 12
12 shr 2 = 3
поскольку 3=112, после сдвига влево на 2 позиции 112 преобразуется в 11002=12, а 12=11002 после сдвига вправо на 2 позиции преобразуется в 112=3.
Операции сравнения
Операции сравнения <, >, <=, >=, =, <> возвращают значение типа boolean и применяются к операндам простого типа и к строкам.
Операции = и <> также применяются ко всем типам. Для размерных типов по умолчанию сравниваются значения, для ссылочных типов - ссылки. Можно переопределить это поведение, перегрузив операции = и <>. Аналогично можно перегрузить все операции сравнения для типов записей и классов, вводимых пользователем.
Строковые операции
К строкам применимы все операции сравнения <, >, <=, >=, =, <>. Сравнение строк на неравенство осуществляется лексикографически: s1 < s2 если для первого несовпадающего символа с номером i s1[i]<s2[i] или все символы строк совпадают, но s1 короче s2.
Кроме этого, к строкам и символам применима операция конкатенации (слияния) +, ее результат имеет строковый тип.
Например, 'a'+'b'='ab'.
К строкам также применима операция +=:
s += s1; // s := s + s1;
Строка может складываться с числом, при этом число предварительно преобразуется к строковому представлению:
s := 'Ширина: '+15; // s = 'Ширина: 15'
s := 20.5+''; // s = '20.5'
s += 1; // s = '20.51'
Над строками и целыми определена операция *: s*n и n*s означает строку, образованную из строки s, повторенной n раз:
s := '*'*10; // s = '**********'
s := 5*'ab' // s = 'ababababab'
s := 'd'; s *= 3; // s = 'ddd'
Операции с указателями
Ко всем указателям применимы операции сравнения = и <>.
К типизированным указателям применима операция разыменования ^: если p является указателем на тип T, то p^ - элемент типа T, на который указывает p. Указатели pointer разыменовывать нельзя.
Операции с множествами
К множествам с базовыми элементами одного типа применимы операции + (объединение), - (разность) и * (пересечение), а также операторы +=, -= и *=:
var s1,s2,s: set of byte;
begin
s1 := [1..4];
s2 := [2..5];
s := s1 + s2; // s = [1..5]
s := s1 - s2; // s = [1]
s := s1 * s2; // s = [2..4]
// s += s1 эквивалентно s := s + s1
// s -= s1 эквивалентно s := s - s1
// s *= s1 эквивалентно s := s * s1
s += [3..6]; // s = [2..6]
s -= [3]; // s = [2,4..6]
s *= [1..5]; // s = [2,4..5]
end.
К множествам с базовыми элементами одного типа применимы также операции сравнения = (равенство), <> (неравенство), <= (нестрого вложено), < (строго вложено), >= (нестрого содержит) и > (строго содержит):
[1..3] = [1,2,3]
['a'..'z'] <> ['0'..'9']
[2..4] < [1..5]
[1..5] <= [1..5]
[1..5] > [2..4]
[1..5] >= [1..5]
Но неверно, что [1..5] < [1..5].
Наконец, операция in определяет, принадлежит ли элемент множеству: 3 in [2..5] вернет True, 1 in [2..5] вернет False.
Операция @
Операция @ применяется к переменной и возвращает ее адрес. Тип результата представляет собой типизированный указатель на тип переменной. Например:
var
r: real;
pr: ^real := @r;
Операции is и as
Операция is предназначена для проверки того, имеет ли классовая переменная указанный динамический тип. Операция as позволяет безопасно преобразовать переменную одного классового типа к другому классовому типу (в отличие от явного приведения классового типа).
Операция is имеет вид:
a is ClassType
и возвращает True если a принадлежит к классу ClassType или одному из его потомков.
Например, если Base и Derived - классы, причем, Derived - потомок Base, переменные b и d имеют соответственно типы Base и Derived, то выражения b is Base и d is Base возвращают True, а b is Derived - False.
Операция as имеет вид:
a as ClassType
и возвращает ссылку на объект типа ClassType если преобразование возможно, в противном случае возвращает nil.
Например, в программе
type
Base = class
end;
Derived = class(Base)
procedure p;
begin
end;
end;
var b: Base;
begin
b := new Base;
writeln(b is Derived);
b := new Derived;
writeln(b is Derived);
end.