Программирование. Принципы и практика использования C++ Исправленное издание

Страуструп Бьерн

bitset<12345> lots;

Здесь объект

lots

будет содержать одни нули, а

dword_bits

— 112 нулей, за которыми следуют 16 явно заданных битов. Если вы попытаетесь проинициализировать объект класса

bitset

строкой, состоящей из символов, отличающихся от

'0'

и

'1'

, то будет сгенерировано исключение

std::invalid_argument

.

string s;

cin>>s;

bitset<12345> my_bits(s); // может генерировать исключение

// std::invalid_argument

К объектам класса

bitset

можно применять обычные операции над битами. Предположим, что переменные

b1

,

b2

и

b3

являются объектами класса

bitset

.

b1 = b2&b3; // и

b1 = b2|b3; // или

b1 = b2^b3; // xor

b1 = ~b2; // дополнение

b1 = b2<<2; // сдвиг влево

b1 = b2>>3; // сдвиг вправо

По существу, при выполнении битовых операций (поразрядных логических операций) объект класса

bitset

ведет себя как переменная типа

unsigned int

(раздел 25.5.3), имеющая произвольный, заданный пользователем размер. Все, что можно делать с переменной типа

unsigned int

(за исключением арифметических операций), вы можете делать и с объектом класса

bitset

. В частности, объекты класса

bitset

полезны при вводе и выводе.

cin>>b; // считываем объект класса bitset

// из потока ввода

cout<<bitset<8>('c'); // выводим битовую комбинацию для символа 'c'

Считывая данные в объект класса

bitset

, поток ввода ищет нули и единицы. Рассмотрим пример.

10121

Число

101

будет введено, а число

21

останется в потоке.

Как в байтах и в словах, биты в объектах класса

bitset

нумеруются справа налево (начиная с самого младшего бита и заканчивая самым старшим), поэтому, например, числовое значение седьмого бита равно

2⁷

.

Для объектов класса

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

, минус один, и еще раз минус один, т.е. 2¹⁵–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)