Таким образом, с формальной точки зрения большинство циклов в этой книге было ошибочным и могло вызвать проблемы, т.е. для встроенных систем мы должны либо проверять, что цикл никогда не достигнет критической точки, либо заменить его другой конструкцией. Для того чтобы избежать этой проблемы, мы можем использовать либо тип size_type, предоставленный классом
vector
, либо итераторы.
for (vector<int>::size_type i = 0; i<v.size(); ++i)
cout << v[i] << '\n';
for (vector<int>::iterator p = v.begin(); p!=v.end(); ++p)
cout << *p << '\n';
Тип
size_type
не имеет знака, поэтому первая форма целых чисел (без знака) имеет на один значащий бит больше, чем версия типа int, рассмотренная выше. Это может иметь значение, но следует иметь в виду, что увеличение происходит только на один байт (т.е. количество выполняемых операций может быть удвоено). Циклы, использующие итераторы, таких ограничений не имеют.
ПОПРОБУЙТЕ
Следующий пример может показаться безобидным, но он содержит бесконечный цикл:
void infinite()
{
unsigned char max = 160; // очень большое
for (signed char i=0; i<max; ++i)
cout << int(i) << '\n';
}
Выполните его и объясните, почему это происходит.
По существу, есть две причины, оправдывающие использование для представления обычных целых чисел типа int без знака, а не набора битов (не использующего операции
+
,
–
,
*
и
/
).
• Позволяет повысить точность на один бит.
• Позволяет отразить логические свойства целых чисел в ситуациях, когда они не могут быть отрицательными.
Из-за причин, указанных выше, программисты отказались от использования счетчиков цикла без знака.
Проблема, сопровождающая использование целых чисел как со знаком, так и без знака, заключается в том, что в языке С++ (как и в языке С) они преобразовываются одно в другое непредсказуемым и малопонятным образом.
Рассмотрим пример.
unsigned int ui = –1;
int si = ui;
int si2 = ui+2;
unsigned ui2 = ui+2;
Удивительно, но факт: первая инициализация прошла успешно, и переменная
ui
стала равной 4294967295. Это число представляет собой 32-битовое целое число без знака с тем же самым представлением (битовой комбинацией), что и целое число –1 без знака (одни единицы). Одни люди считают это вполне допустимым и используют число –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);
