без знака (одни единицы). Одни люди считают это вполне допустимым и используют число –1 как сокращенную запись числа, состоящего из одних единиц, другие считают это проблемой. То же самое правило преобразования применимо к переводу чисел без знака в числа со знаком, поэтому переменная si примет значение –1. Можно было ожидать, что переменная si2 станет равной 1 (–1+2 == 1), как и переменная ui2. Однако переменная ui2 снова нас удивила: почему 4294967295+2 равно 1? Посмотрим на 4294967295 как на шестнадцатеричное число (0xffffffff), и ситуация станет понятнее: 4294967295 — это наибольшее 32-битовое целое число без знака, поэтому 4294967297 невозможно представить в виде 32-битового целого числа — неважно, со знаком или без знака. Поэтому либо следует сказать, что операция 4294967295+2 приводит к переполнению или (что точнее), что целые числа без знака поддерживают модулярную арифметику; иначе говоря, арифметика 32-битовых целых чисел является арифметикой по модулю 32.
Вам все понятно? Даже если так, мы все равно убеждены, что использование целых чисел без знака ради дополнительного повышения точности на один бит — это игра с огнем. Она может привести к путанице и стать источником ошибок.
Что произойдет при переполнении целого числа? Рассмотрим пример.
Int i = 0;
while (++i) print(i); // выводим i как целое с пробелом
Какая последовательность значений будет выведена на экран? Очевидно, что это зависит от определения типа Int (на всякий случай отметим, что прописная буква I не является опечаткой). Работая с целочисленным типом, имеющим ограниченное количество битов, мы в конечном итоге получим переполнение. Если тип Int не имеет знака (например, unsigned char, unsigned int или unsigned long long), то операция ++ является операцией модулярной арифметики, поэтому после наибольшего числа, которое мы можем представить, мы получим нуль (и цикл завершится). Если же тип Int является целым числом со знаком (например, signed char), то числа внезапно станут отрицательными и цикл будет продолжаться, пока счетчик не станет равным нулю (и тогда цикл завершится). Например, для типа signed char мы увидим на экране числа 1 2 ... 126 127 –128 –127 ... –2–1.
Что происходит при переполнении целых чисел? В этом случае мы работаем так, будто в нашем распоряжении есть достаточное количество битов, и отбрасываем ту часть целого числа, которая не помещается в память, где мы храним результат. Эта стратегия приводит к потере крайних левых (самых старших) битов. Такой же эффект можно получить с помощью следующего кода:
int si = 257; // не помещается в типе char
char c = si; // неявное преобразование в char
unsigned char uc = si;
signed char sc = si;
print(si); print(c); print(uc); print(sc); cout << 'n';
si = 129; // не помещается в signed char
c = si;
uc = si;
sc = si;
print(si); print(c); print(uc); print(sc);
Получаем следующий результат:
Объяснение этого результата таково: число 257 на два больше, чем можно представить с помощью восьми битов (255 равно “восемь единиц”), а число 129 на два больше, чем можно представить с помощью семи битов (127 равно “семь единиц”), поэтому устанавливается знаковый бит. Кстати, эта программа демонстрирует, что тип char на нашем компьютере имеет знак (переменная c ведет себя как переменная sc и отличается от переменной uc).
ПОПРОБУЙТЕ
Напишите эти битовые комбинации на листке бумаги. Затем попытайтесь вычислить результат для si=128. После этого выполните программу и сравните свое предположение с результатом вычислений на компьютере.
Кстати, почему мы использовали функцию print()? Ведь мы могли бы использовать оператор вывода.
cout << i << ' ';
Однако, если бы переменная i имела тип char, мы увидели бы на экране символ, а не целое число. По этой причине, для того чтобы единообразно обрабатывать все целочисленные типы, мы определили функцию print().
template<class T> void print(T i) { cout << i << 't'; }
void print(char i) { cout << int(i) << 't'; }
void print(signed char i) { cout << int(i) << 't'; }
void print(unsigned char i) { cout << int(i) << 't'; }
Вывод: вы можете использовать целые числа без знака вместо целых чисел со знаком (включая обычную арифметику), но избегайте этого, поскольку это ненадежно и приводит к ошибкам.
• Никогда не используйте целые числа без знака просто для того, чтобы получить еще один бит точности.
• Если вам необходим один дополнительный бит, то вскоре вам потребуется еще один.
К сожалению, мы не можем совершенно избежать использования арифметики целых чисел без знака.
• Индексирование контейнеров в стандартной библиотеке осуществляется целыми числами без знака.
• Некоторые люди любят арифметику чисел без знака.
25.5.4. Манипулирование битами
Зачем вообще нужно манипулировать битами? Ведь многие из нас предпочли бы этого не делать. “Возня с битами” относится к низкому уровню и открывает возможности для ошибок, поэтому, если у нас есть альтернатива, следует использовать ее. Однако биты настолько важны и полезны, что многие программисты не могут их игнорировать. Это может звучать довольно грозным и обескураживающим предупреждением, но оно хорошо продумано. Некоторые люди действительно любят возиться с битами и байтами, поэтому следует помнить, что работа с битами иногда необходима (и даже может принести удовольствие), но ею не следует злоупотреблять. Процитируем Джона Бентли: “Люди, развлекающиеся с битами, будут биты” (“People who play with bits will be bitten”).
Итак, когда мы должны манипулировать битами? Иногда они являются естественными объектами нашей предметной области, поэтому естественными операциями в таких приложениях являются операции над битами. Примерами таких приложений являются индикаторы аппаратного обеспечения (“влаги”), низкоуровневые коммуникации (в которых мы должны извлекать значения разных типов из потока байтов), графика (в которой мы должны составлять рисунки из нескольких уровней образов) и кодирование (подробнее о нем — в следующем разделе).
Для примера рассмотрим, как извлечь (низкоуровневую) информацию из целого числа (возможно, из-за того, что мы хотим передать его