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

фиксированным количеством битов (например, 8, 16, 32 и 64), чтобы компьютер мог выполнять логические операции над ними с оптимальной скоростью, используя операции, непосредственно обеспечиваемые аппаратным обеспечением. В противоположность им средства стандартной библиотеки позволяют работать с произвольным количеством битов. Это может ограничивать производительность, но не следует беспокоиться об этом заранее: библиотечные средства могут быть — и часто бывают — оптимизированными, если количество выбранных вами битов соответствует требованиям аппаратного обеспечения.

Рассмотрим сначала целые числа. Для них в языке C++ предусмотрены побитовые логические операции, непосредственно реализуемые аппаратным обеспечением. Эти операции применяются к каждому биту своих операндов.

Вам может показаться странным то, что в число фундаментальных операций мы включили “исключительное или” (^, которую иногда называют “xor”). Однако эта операция играет важную роль во многих графических и криптографических программах. Компилятор никогда не перепутает побитовый логический оператор << с оператором вывода, а вы можете. Для того чтобы этого не случалось, помните, что левым операндом оператора вывода является объект класса ostream, а левым операндом логического оператора — целое число.

Следует подчеркнуть, что оператор & отличается от оператора &&, а оператор | отличается от оператора || тем, что они применяются к каждому биту своих операндов по отдельности (раздел A.5.5), а их результат состоит из такого же количества битов, что и операнды. В противоположность этому операторы && и || просто возвращают значение true или false.

Рассмотрим несколько примеров. Обычно битовые комбинации выражаются в шестнадцатеричном виде. Для полубайта (четыре бита) используются следующие коды.

Для представления чисел, не превышающих девяти, можно было бы просто использовать десятичные цифры, но шестнадцатеричное представление позволяет не забывать, что мы работаем с битовыми комбинациями. Для байтов и слов шестнадцатеричное представление становится действительно полезным. Биты, входящие в состав байта, можно выразить с помощью двух шестнадцатеричных цифр.

Итак, используя для простоты тип unsigned (раздел 25.5.3), можем написать следующий фрагмент кода:

unsigned char a = 0xaa;

unsigned char x0 = ~a; // дополнение a

unsigned char b = 0x0f;

unsigned char x1 = a&b; // a и b

unsigned char x2 = a^b; // исключительное или: a xor b

unsigned char x3 = a<<1; // сдвиг влево на один разряд

Вместо бита, который был “вытолкнут” с самой старшей позиции, в самой младшей позиции появляется нуль, так что байт остается заполненным, а крайний левый бит (седьмой) просто исчезает.

unsigned char x4 == a>>2; // сдвиг вправо на два разряда

В двух позициях старших битов появились нули, которые обеспечивают заполнение байта, а крайние правые биты (первый и нулевой) просто исчезают.

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

int main()

{

  int i;

  while (cin>>i)

    cout << dec << i << "=="

         << hex << "0x" << i << "=="

         << bitset<8*sizeof(int)>(i) << 'n';

}

Для того чтобы вывести на печать отдельные биты целого числа, используется класс bitset из стандартной библиотеки.

bitset<8*sizeof(int)>(i)

Класс bitset хранит фиксированное количество битов. В данном случае мы использовали количество битов, равное размеру типа int — 8*sizeof(int), — и инициализировали объект класса bitset целым числом i.

ПОПРОБУЙТЕ

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

25.5.2. Класс bitset

Для представления наборов битов и работы с ними используется стандартный шаблонный класс bitset из заголовка <bitset>. Каждый объект класса bitset имеет фиксированный размер, указанный при его создании.

bitset<4> flags;

bitset<128> dword_bits;

bitset<12345> lots;

Объект класса bitset по умолчанию инициализируется одними нулями, но обычно у него есть инициализатор. Инициализаторами объектов класса bitset могут быть целые числа без знака или строки, состоящие из нулей и единиц:

bitset<4> flags = 0xb;

bitset<128> dword_bits(string("1010101010101010"));

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 нумеруются справа налево (начиная с самого младшего бита и заканчивая самым