старшим), поэтому, например, числовое значение седьмого бита равно 27.
Для объектов класса bitset нумерация является не просто соглашением поскольку класс bitset поддерживает индексирование битов. Рассмотрим пример.
int main()
{
const int max = 10;
bitset<max> b;
while (cin>>b) {
cout << b << 'n';
for (int i =0; i<max; ++i) cout << b[i]; // обратный
// порядок
cout << 'n';
}
}
Если вам нужна более полная информация о классе bitset, ищите ее в Интернете, в справочниках и учебниках повышенной сложности.
25.5.3. Целые числа со знаком и без знака
Как и во многих языках программирования, целые числа в языке С++ бывают двух видов: со знаком и без него. Целые числа без знака легко представить в памяти компьютера: нулевой бит означает единицу, первый бит — двойку, второй бит — четверку и т.д. Однако представление целого числа со знаком уже создает проблему: как отличить положительные числа от отрицательных? Язык С++ предоставляет разработчикам аппаратного обеспечения определенную свободу выбора, но практически во всех реализациях используется представление в виде двоичного дополнения. Крайний левый бит (самый старший) считается знаковым.
Если знаковый бит равен единице, то число считается отрицательным. Почти повсюду для представления целых чисел со знаком используется двоичное дополнение. Для того чтобы сэкономить место, рассмотрим представление четырехбитового целого числа со знаком.
Битовую комбинацию числа –(x+1) можно описать как дополнение битов числа x (известное также как ~x; см. раздел 25.5.1).
До сих пор мы использовали только целые числа со знаком (например, int). Правила использования целых чисел со знаком и без знака можно было бы сформулировать следующим образом.
• Для числовых расчетов используйте целые числа со знаком (например, int).
• Для работы с битовыми наборами используйте целые числа без знака (например, unsigned int).
Это неплохое эмпирическое правило, но ему трудно следовать, потому что есть люди, которые предпочитают в некоторых арифметических вычислениях работать с целыми числами без знака, и нам иногда приходится использовать их программы. В частности, по историческим причинам, которые возникли еще в первые годы существования языка С, когда числа типа int состояли всего из 16 битов и каждый бит был на счету, функция-член v.size() из класса vector возвращает целое число без знака.
Рассмотрим пример.
vector<int> v;
// ...
for (int i = 0; i<v.size(); ++i) cout << v[i] << 'n';
“Разумный” компилятор может предупредить, что мы смешиваем значения со знаком (т.е. переменную i) и без знака (т.е., v.size()). Такое смешение может привести к катастрофе. Например, счетчик цикла i может оказаться переполненным; иначе говоря, значение v.size() может оказаться больше, чем максимально большое число типа int со знаком. В этом случае переменная i может достигнуть максимально возможного положительного значения, которое можно представить с помощью типа int со знаком (два в степени, равной количеству битов в типе int, минус один, и еще раз минус один, т.е. 215–1). Тогда следующая операция ++ не сможет вычислить следующее за максимальным целое число, а вместо этого вернет отрицательное значение. Этот цикл никогда не закончится! Каждый раз, когда мы будем достигать максимального целого числа, мы будем начинать этот цикл заново с наименьшего отрицательного значения типа int. Итак, для 16-битовых чисел типа int этот цикл содержит ошибку (вероятно, очень серьезную), если значение v.size() равно 32*1024 или больше; для 32-битовых целых чисел типа int эта проблема возникнет, только когда счетчик i достигнет значений 2*1024*1024*1024.
Таким образом, с формальной точки зрения большинство циклов в этой книге было ошибочным и могло вызвать проблемы, т.е. для встроенных систем мы должны либо проверять, что цикл никогда не достигнет критической точки, либо заменить его другой конструкцией. Для того чтобы избежать этой проблемы, мы можем использовать либо тип 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