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

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<sup>7</sup>
.

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

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

bitset
нумерация является не просто соглашением поскольку класс
bitset
поддерживает индексирование битов. Рассмотрим пример.

int main()

{

  const int max = 10;

  bitset&lt;max&gt; b;

  while (cin&gt;&gt;b) {

    cout &lt;&lt; b &lt;&lt; '\n';

    for (int i =0; i&lt;max; ++i) cout &lt;&lt; b[i]; // обратный

                                             // порядок

    cout &lt;&lt; '\n';

  }

}

Если вам нужна более полная информация о классе

bitset
, ищите ее в Интернете, в справочниках и учебниках повышенной сложности. 

25.5.3. Целые числа со знаком и без знака

Как и во многих языках программирования, целые числа в языке С++ бывают двух видов: со знаком и без него. Целые числа без знака легко представить в памяти компьютера: нулевой бит означает единицу, первый бит — двойку, второй бит — четверку и т.д. Однако представление целого числа со знаком уже создает проблему: как отличить положительные числа от отрицательных? Язык С++ предоставляет разработчикам аппаратного обеспечения определенную свободу выбора, но практически во всех реализациях используется представление в виде двоичного дополнения. Крайний левый бит (самый старший) считается знаковым.

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

Если знаковый бит равен единице, то число считается отрицательным. Почти повсюду для представления целых чисел со знаком используется двоичное дополнение. Для того чтобы сэкономить место, рассмотрим представление четырехбитового целого числа со знаком.

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

Битовую комбинацию числа

–(x+1)
можно описать как дополнение битов числа
x
(известное также как
~x
; см. раздел 25.5.1).

До сих пор мы использовали только целые числа со знаком (например,

int
). Правила использования целых чисел со знаком и без знака можно было бы сформулировать следующим образом.

 

Программирование. Принципы и практика использования C++ Исправленное издание - _002.png
 • Для числовых расчетов используйте целые числа со знаком (например,
int
).

  • Для работы с битовыми наборами используйте целые числа без знака (например,

unsigned int
).

 

Программирование. Принципы и практика использования C++ Исправленное издание - _003.png
 Это неплохое эмпирическое правило, но ему трудно следовать, потому что есть люди, которые предпочитают в некоторых арифметических вычислениях работать с целыми числами без знака, и нам иногда приходится использовать их программы. В частности, по историческим причинам, которые возникли еще в первые годы существования языка С, когда числа типа
int
состояли всего из 16 битов и каждый бит был на счету, функция-член
v.size()
из класса vector возвращает целое число без знака. 

 

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

vector&lt;int&gt; v;

// ...

for (int i = 0; i&lt;v.size(); ++i) cout &lt;&lt; v[i] &lt;&lt; '\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.