3.1. Неочевидные особенности целых чисел
Аппаратная реализация целочисленной арифметики достаточно очевидна и в большинстве случаев не приносит неожиданностей. К тому же возможные проблемы в том или ином виде упомянуты во многих книгах по Delphi, поэтому даже начинающий программист обычно готов к ним. В этом разделе мы компактно изложим эти проблемы и объясним причины их появления.
3.1.1. Аппаратное представление целых чисел
Delphi относится к языкам, в которых целые типы данных максимально приближены к аппаратной реализации целых чисел процессором. Это позволяет выполнять операции с целочисленными данными максимально быстро, но заставляет программиста учитывать аппаратные ограничения.
Примечание
Такая реализация целых чисел может также приводить к проблемам при переносе языка на другую аппаратную платформу, но для Delphi это, видимо, не очень актуально.
Целые числа могут быть знаковыми и беззнаковыми. Сначала рассмотрим формат более простых беззнаковых чисел. Если у нас есть N двоичных разрядов для хранения такого числа, то мы можем представить любое число от 0 до 2N-1. В Delphi беззнаковые целые представлены фундаментальными типами Byte (N=8, диапазон 0..255), Word (N=16, диапазон 0..65 535) и LongWord (N=32, диапазон 0..4 294 967 295).
Примечание
Фундаментальными называются те типы данных, разрядность которых не зависит от аппаратной платформы. Кроме них существуют еще общие (generic) типы, разрядность которых определяется разрядностью платформы. В Delphi это типы Integer (знаковое целое) и Cardinal (беззнаковое целое. В имеющейся реализации они имеют 32 разряда, но при переходе на 64-разрядные компиляторы следует ожидать что эти типы также станут 64-разрядными. В частности, в 16-разрядном Turbo Pascal тип Integer был 16-разрядным а типа Cardinal там не было).
Знаковые числа устроены несколько сложнее. Старший из N бит, отводящихся на такое число, служит для хранения знака (этот бит называется знаковым). Если этот бит равен нулю, число считается положительным, а оставшиеся N-1 разрядов используются для хранения числа так же, как в случае беззнакового целого (эти разряды мы будем называть беззнаковой частью). В этом случае знаковое число ничем не отличается от беззнакового. Отрицательные значения кодируются несколько сложнее. Когда все разряды (включая знаковый бит) равны единице, это соответствует значению -1. Рассмотрим это на примере однобайтного знакового числа. Числу -1 в данном случае соответствует комбинация 1 1111111 (знаковый бит мы будем отделять от остальных пробелом), т.е. беззнаковая часть числа содержит максимально возможное значение -127. Числу -2 соответствует комбинация 1 1111110, т.е. в беззнаковой части содержится 126. В общем случае отрицательное число, хранящееся в N разрядах равно X-2N-1, где X — положительное число, хранящееся в беззнаковой части. Таким образом, N разрядов позволяют представить знаковое целое в диапазоне -2N-1..2N-1-1, причем значению -2N-1 соответствует ситуация, когда все биты, кроме знакового равны нулю.
Такая на первый взгляд не очень удобная система позволяет унифицировать операции для знаковых и беззнаковых чисел. Для примера рассмотрим число 11111110. Если его рассматривать как беззнаковое, оно равно 254, если как знаковое, то -2. Вычитая из него, например, 3, мы должны получить 251 и -5 соответственно. Как нетрудно убедиться, в беззнаковой форме 251 — это 11111011. И число -5 в знаковой форме — это тоже 11111011, т.е. результирующее состояние разрядов зависит только от начального состояния этих разрядов и вычитаемого числа и не зависит от того, знаковое или беззнаковое число представляют эти разряды. И это утверждение справедливо не только для выбранных чисел, но и вообще для любых чисел, если ни они, ни результат операции не выходят за пределы допустимого диапазона. То же самое верно для операции сложения. Поэтому в системе команд процессора нет отдельно команд знакового и беззнакового сложения и вычитания — форматы чисел таковы, что можно обойтись одной парой команд (для умножения и деления это неверно, поэтому существуют отдельно команды знакового и беззнакового умножения и деления).
Ранее мы специально оговорили, что такое удобное правило действует только до тех пор, пока аргументы и результат остаются в рамках допустимого диапазона. Рассмотрим, что произойдет, если мы выйдем за его пределы. Пусть в беззнаковой записи нам нужно из 130 вычесть 10. 130 — это 10000010, после вычитания получим 01111000 (120). Но если попытаться интерпретировать эти двоичные значения как знаковые числа, получится, что из -126 мы вычитаем 10 и получаем 120. Такими парадоксальными результатами приходится расплачиваться за унификацию операций со знаковыми и беззнаковыми числами.
Рассмотрим другой пример: из пяти (в двоичном представлении 00000101) вычесть десять (00001010). Здесь уместно вспомнить вычитание в столбик, которое изучается в школе: если в разряде уменьшаемого стоит цифра, большая, чем в соответствующем разряде вычитаемого, то из старшего разряда уменьшаемого приходится занимать единицу. То же самое и здесь: чтобы вычесть большее число из меньшего, как бы занимается единица из несуществующего девятого разряда. Это можно представить так: из числа (1)00000101 вычитается (0)00001010 и получается (0)11111011 (несуществующий девятый разряд показан в скобках: после получения результата мы про него снова забываем). Если интерпретировать полученный результат как знаковое целое, то он равен -5, т.е. именно тому, что и должно быть. Но с точки зрения беззнаковой арифметики получается, что 5-10=251.
Приведенные примеры демонстрировали ситуации, когда результат укладывался в один из диапазонов (знаковый или беззнаковый), но не укладывался в другой. Рассмотрим, что будет, если результат не попадает ни в тот, ни в другой диапазон. Пусть нам нужно сложить 10000000 и 10000000. При таком сложении снова появляется несуществующий девятый разряд, но на этот раз из него единица не занимается, а в него переносится лишняя. Получается (1)00000000. Несуществующий разряд потом игнорируется. С точки зрения знаковой интерпретации получается, что 128 + 128 = 0. С точки зрения беззнаковой — что -128 + (-128) = 0, т.е. оба результата, как и можно было ожидать с самого начала, оказываются некорректными.
Знаковые целые представлены в Delphi типами ShortInt (N=8, диапазон -128..127), SmallInt (N=16, диапазон -32 768..32 767), LongInt (N=32, диапазон -2 147 483 648..2 147 483 647) и Int64 (N=64, диапазон -9 223 372 036 854 775 808..9 223 372 036 854 775 807).
Примечание
32-разрядные процессоры не могут выполнять операции непосредственно с 64-разрядными числами, поэтому компилятор генерирует код, который обрабатывает это число по частям. Сначала операция сложения или вычитания выполняется над младшими 32-мя разрядами а потом — над старшими 32-мя, причем, если в первой операции занималась единица из несуществующего (в рамках данной операции) 33-го разряда или единица переносилась в него, при второй операции эта единица учитывается.
Далее приведены несколько примеров, иллюстрирующих сказанное.
3.1.2. Выход за пределы диапазона при присваивании
Начнем с рассмотрения простого примера (листинг 3.1. проект Assignment1 на компакт-диске).
Листинг 3.1. Неявное преобразование знакового числа в беззнаковое при присваивании
procedure TForm1.Button1Click(Sender: TObject);
var
X: Byte;
Y: ShortInt;
begin
Y := -1;
X := Y;
Label1.Caption := IntToStr(X);
end;
При выполнении этого примера будет выведено значение 255. Здесь мы сталкиваемся с тем, что все разряды значения Y без дополнительных проверок копируются в X, но если Y интерпретируется как знаковое число, то X — как беззнаковое, а числам 255 и -1 в восьмиразрядном представлении соответствует одна и та же комбинация битов.
Примечание
Промежуточная переменная Y понадобилась потому, что прямо присвоить переменной значение, выходящее за ее диапазон, компилятор не позволит — возникнет ошибка компиляции "Constant expression violates subrange bounds".
Строго говоря, в Delphi предусмотрена защита от подобного присваивания. Если включить опцию Range checking (включается в окне Project/Options... на закладке Compiler или директивой компилятора {$R+} или {$RANGECHECKS ON}), то при попытке присвоения X := Y возникнет исключение ERangeError. Но по умолчанию эта опция отключена (для повышения производительности — дополнительные проверки требуют процессорного времени), поэтому программа без сообщений об ошибке выполняет такое неправильное присваивание.
В следующем примере (листинг 3.2, проект Assignment2 на компакт-диске) мы рассмотрим присваивание числу такого значения, которое не укладывается ни в знаковый, ни в беззнаковый диапазон.
Листинг 3.2. Присваивание переменной значения, выходящего за рамки диапазона
procedure TForm1.Button1Click(Sender: TObject);
var
X: Byte;
Y: Word;
begin
Y := 1618;
X := Y;
Label1.Caption := IntToStr(X)
end;
На экране появится число 82. Разберемся, почему это происходит. Число 1618 в двоичной записи равно 00000110 01010010. При присваивании этого значения переменной X старшие восемь битов "некуда девать", поэтому они просто игнорируются. В результате в Х записывается число 01010010, т.е. 82.
Разумеется, при включенной опции Range checking и в этом случае произойдет исключение ERangeError.
Приведенные примеры показывают два основных источника неожиданностей, возникающих при присваивании значения целой переменной:
1. При смешении знаковых и беззнаковых чисел значение меняется из-за того, что старший бит интерпретируется то как знак числа, то как старший разряд.
2. При присваивании переменной значения, требующего большего числа разрядов, "лишние" разряды просто игнорируются.
Все проблемы при присваивании сводятся к одному из этих случаев или к их комбинации.
Все эти ситуации при выключенной опции Range checking приводят к ошибкам, которые бывает очень трудно обнаружить. Из-за этого рекомендуется включать эту опцию хотя бы на этапе отладки.
В некоторых случаях возможность присваивания значений, выходящих за пределы диапазона переменной, может быть необходимой (например, для реализации "хитрых" алгоритмов или при сопряжении сторонних библиотек, одна из которых использует знаковые типы, другая — беззнаковые). Чтобы включение ERangeError не возникало, следует предусмотреть явное приведение типа. Например, следующий код работает без исключений при включенной опции Range checking (листинг 3.3).
Листинг 3.3. Явное приведение типа для подавления исключений
procedure TForm1.Button1Click(Sender: TObject);
var
X: Byte;
Y: ShortInt;
begin
Y := -1;
X := Byte(Y);
Label1.Caption := IntToStr(X)
end;
В результате его выполнения переменная X получает значение 255.
3.1.3. Переполнение при арифметических операциях
Переполнением принято называть ситуацию, когда при операциях над переменной результат выходит за пределы ее диапазона. Рассмотрим следующий пример (листинг 3.4, проект Overflow1 на компакт-диске).
Листинг 3.4. Переполнение при вычитании
procedure TForm1.Button1Click(Sender: TObject);
var X: Byte;
begin
X := 0;
X := X - 1;
Label1.Caption := IntToStr(X)
end;
Переменная X получит значение 255, поскольку при вычитании получается -1, что в беззнаковом формате соответствует 255. В принципе, этот пример практически эквивалентен примеру Assignment1, за исключением того, что значение -1 появляется в результате арифметических операций.
Немного изменим этот пример — заменим оператор вычитания функцией Dec (листинг 3.5, пример Overflow2 на компакт-диске).
Листинг 3.5. Переполнение при декременте
{$R+}
procedure TForm1.Button1Click(Sender: TObject);
var X: Byte;
begin
X := 0;
Dec(X);
Label1.Caption := IntToStr(X);
end;
Результат получается тот же (X получает значение 255), но обратите внимание: несмотря на то, что опция Range checking включена, исключение не возникает. Этим пример Overflow2 отличается от Overflow1 — там исключение возникнет. Связано это с тем, что переполнение при использовании Dec и подобных ей функций контролируется другой опцией — Overflow checking (в коде программы включается директивой {$Q+} или {$OVERFLOWCHECKS ON}). Эта опция по умолчанию тоже отключена и ее также рекомендуется включать при отладке. При ее включении в данном примере возникнет исключение EIntOverflow.
3.1.4. Сравнение знакового и беззнакового числа
Посмотрим, что произойдет, если мы попытаемся сравнить знаковое и беззнаковое число (листинг 3.6, пример Compare1 на компакт-диске).
Листинг 3.6. Сравнение "одинаковых" знакового и беззнакового числа
procedure TForm1.Button1Click(Sender: TObject);
var
X: Byte;
Y: ShortInt;
begin
Y := -1;
X := Y;
if X = Y then Label1.Caption := 'Равно';
else Label1.Caption := 'He равно';
end;
В окне появится надпись Не равно, хотя последовательность битов в переменных X и Y будет, как мы уже знаем, одинаковая. Надпись соответствует действительности — X (255) действительно не равно Y (-1). Разберемся, почему так происходит.
Те, кто успел самостоятельно откомпилировать пример Compare1, могли заметить предупреждение компилятора на строке со сравнением: "Comparing signed and unsigned types — widened both operands". Это предупреждение все объясняет: компилятор, зная, что совпадение наборов битов не гарантирует равенство знакового и беззнакового выражения, сначала "расширяет" типы выражений до того типа, чей диапазон целиком вмещает оба требуемых диапазона и лишь затем выполняет сравнение. Это обеспечивает правильный результат сравнения, но требует дополнительных ресурсов, поэтому компилятор выдает предупреждение.
Аналогичные действия компилятор выполнит при сравнении выражений типов Word и SmallInt, а также LongInt и LongWord. Тип Int64 не имеет беззнакового аналога, поэтому операнды этого типа при сравнении компилятор не "расширяет".
Явное приведение типов позволяет избавиться от операций по расширению типа и ограничиться побитовым сравнением (листинг 3.7. пример Compare2 на компакт-диске).
Листинг 3.7. Явное приведение типов при сравнении
procedure TForm1.Button1Click(Sender: TObject);
var
X: Byte;
Y: ShortInt;
begin
Y := -1;
X := Y;
if X = Byte(Y) then Label1.Caption := 'Равно'
else Label1.Caption := 'Не равно';
end;
При компиляции такого кода не выдается никаких предупреждений, но и результат сравнения будет неверным: Равно.
Примечание
Операции >, <, >= и <= тоже работают по-разному для знаковых и беззнаковых чисел. Пусть, например, сравниваются числа 01000000 и 11000000. В беззнаковом формате это 64 и 192, поэтому первое число меньше второго. А в знаковом это 64 и -64, т. е. первое число больше. Из-за этого для операций сравнения для знаковых и беззнаковых чисел в системе команд процессора существуют разные команды. В литературе, чтобы подчеркнуть это, часто используются различные названия операций в зависимости от формата: для знаковых чисел — "больше" и "меньше", для беззнаковых — "выше" и "ниже".
3.1.5. Неявное преобразование в цикле for
Рассмотрим программу (пример ForRange на компакт-диске), на форме которой находятся кнопка и панель, причем кнопка (это важно!) — не на панели, а на форме, а на панели нет никаких компонентов. Обработчик нажатия на кнопку выглядит следующим образом (листинг 3.8).
Листинг 3.8. Обработчик нажатия кнопки
procedure TForm1.Button1Click(Sender: TObject);
var
I: Cardinal;
begin
for I := 0 to Panel1.ControlCount - 1 do
Panel1.Controls[I].Tag := 1;
end;
На первый взгляд кажется, что при нажатии на кнопку ничего не должно происходить, т.к. на панели никаких визуальных компонентов нет, и цикл for не должен выполниться ни разу. Тем не менее нажатие на кнопку вызывает исключение Access violation.
При нулевом количестве компонентов на панели выражение Panel1.ControlCount - 1 должно давать значение -1. Но поскольку переменная цикла имеет тип Сardinal, эта комбинация битов интерпретируется как 4 294 967 295, верхняя граница оказывается больше нижней, и цикл начинает выполняться, обращаясь к несуществующим элементам управления. Отсюда и ошибка.
Ошибка исчезнет, если тип переменной I изменить на Integer — в этом случае верхняя граница цикла получит корректное значение -1, и цикл действительно не выполнится ни разу. Если на панели будет находиться хотя бы один компонент, ошибки тоже не будет, потому что верхняя граница цикла не выйдет из диапазона неотрицательных чисел.
Получается, что в ситуации, когда использование беззнакового типа кажется вполне безобидным (действительно, индексы списка не могут быть отрицательными), нас подстерегает "подводный камень", связанный с тем. что верхняя граница цикла может оказаться отрицательной и будет неявно приведена к большому положительному числу. Поэтому в цикле предпочтительнее переменная знакового типа Integer, а если по каким-то причинам приходится использовать переменную типа Cardinal, то необходимо внимательно следить за тем, какие значения принимают границы типа.
Примечание
Строго говоря, аналогичная проблема может возникнуть и со знаковыми типами, если границы цикла for переходят допустимый диапазон этих чисел, просто циклы, переменная которых принимает значения вблизи границ диапазона типа Integer, встречаются гораздо реже.
