Язык программирования C++. Пятое издание - Стенли Липпман

unsigned char b1 = 0145; 0 1 1 0 0 1 0 1

unsigned char b2 = 0257; 1 0 1 0 1 1 1 1

b1 & b2   Все 24 старших бита 0   0 0 1 0 0 1 0 1

b1 | b2   Все 24 старших бита 0   1 1 1 0 1 1 1 1

b1 ^ b2   Все 24 старших бита 0   1 1 0 0 1 0 1 0

Каждая битовая позиция результата побитового оператора AND (&) содержит 1, если оба операнда содержат 1 в этой позиции; в противном случае результат — 0. У побитового оператора OR (|) бит содержит 1, если один или оба операнда содержат 1; в противном случае результат — 0. Для побитового оператора XOR (^) бит содержит 1, если любой, но не оба операнда содержат 1; в противном случае результат — 0.

Побитовые и логические (см. раздел 4.3) операторы нередко путают. Например, путают побитовый оператор & с логическим &&, побитовый | с логическим || и побитовый ~ с логическим !.

Использование побитовых операторов

Рассмотрим пример использования побитовых операторов. Предположим, что есть класс с 30 учениками. Каждую неделю класс отвечает на контрольные вопросы с оценкой "сдано/не сдано". Результаты всех контрольных записываются, по одному биту на ученика, чтобы представить успешную оценку или нет. Каждую контрольную можно представить в виде беззнакового целочисленного значения.

unsigned long quiz1 = 0; // это значение используется

                         // как коллекция битов

Переменная quiz1 определена как unsigned long. Таким образом, на любой машине она будет содержать по крайней мере 32 бита. Переменная quiz1 инициализируется явно, чтобы ее значение было определено изначально.

Учитель должен быть способен устанавливать и проверять отдельные биты. Например, должна быть возможность установить бит, соответствующий ученику номер 27, означающий, что этот ученик сдал контрольную. Чтобы указать, что ученик 27 прошел контрольную, создадим значение, у которого установлен только бит номер 27. Если затем применить побитовый оператор OR к этому значению и значению переменной quiz1, то все биты, кроме бита 27, останутся неизменными.

В данном примере счет битов переменной quiz1 начинается с 0, соответствующего младшему биту, 1 соответствует следующему биту и т.д.

Чтобы получить значение, означающее, что ученик 27 сдал контрольную, используется оператор сдвига влево и целочисленный литерал 1 типа unsigned long (см. раздел 2.1.3).

1UL << 27 // создает значение только с одним установленным битом

          // в позиции 27

Первоначально переменная 1UL имеет 1 в самом младшем бите и по крайней мере 31 нулевой бит. Она определена как unsigned long, поскольку тип int гарантированно имеет только 16 битов, а необходимо по крайней мере 27. Это выражение сдвигает 1 на 27 битовых позиций, вставляя в биты позади 0.

К этому значению и значению переменной quiz1 применяется оператор OR. Поскольку необходимо изменить значение самой переменной quiz1, используем составной оператор присвоения (см. раздел 4.4):

quiz1 |= 1UL << 27; // указать, что ученик номер 27 сдал контрольную

Оператор |= выполняется аналогично оператору +=.

quiz1 = quiz1 | 1UL << 27; // эквивалент quiz1 |= 1UL << 21;

Предположим, что учитель пересмотрел контрольные и обнаружил, что ученик 27 фактически списал работу. Теперь учитель должен сбросить бит 27 в 0. На сей раз необходимо целое число, бит 27 которого сброшен, а все остальные установлены в 1. Применение побитового AND к этому значению и значению переменной quiz1 позволяет сбросить только данный бит:

quiz1 &= ~(1UL << 27); // ученик номер 27 не прошел контрольную

Мы получаем значение со всеми установленными битами, кроме бита 27, инвертируя предыдущее значение. У него все биты были сброшены в 0, кроме бита 27, который был установлен в 1. Применение побитового NOT к этому значению сбросит бит 27, а все другие установит. Применение побитового AND к этому значению и значению переменной quiz1 оставит неизменными все биты, кроме бита 27.

И наконец, можно узнать, как дела у ученика 27:

bool status = quiz1 & (1UL << 27); // как дела у ученика 27?

Здесь оператор AND применяется к значению с установленным битом 27 и значением переменной quiz1. Результат отличен от нуля (т.е. истинен), если бит 27 в значении переменной quiz1 установлен; в противном случае он нулевой.

Операторы сдвига (они же ввода и вывода) имеют левосторонний порядок

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

Поскольку операторы сдвига имеют левосторонний порядок, выражение

cout << "hi" << " there" << endl;

выполняется так:

( (cout << "hi") << " there" ) << endl;

В этом операторе операнд "hi" группируется с первым символом <<. Его результат группируется со вторым, а его результат с третьим символом.

Приоритет операторов сдвига средний: ниже, чем у арифметических операторов, но выше, чем у операторов отношения, присвоения и условных операторов. Эти различия в уровнях приоритета свидетельствуют о том, что для правильной группировки операторов с более низким приоритетом следует использовать круглые скобки.

cout << 42 + 10;   // ok: приоритет + выше, поэтому выводится сумма

cout << (10 < 42); // ok: группировку определяют скобки; выводится 1

cout << 10 < 42;   // ошибка: попытка сравнить cout с 42!

Последний оператор cout интерпретируется так

(cout << 10) < 42;

Он гласит: "записать 10 в поток cout, а затем сравнить результат (т.е. поток cout) со значением 42".

Упражнения раздела 4.8

Упражнение 4.25. Каково значение выражения ~'q' << 6 на машине с 32-битовыми целыми числами и 8-битовыми символами, с учетом, что символ 'q' имеет битовое представление 01110001?

Упражнение 4.26. Что будет, если в приведенном выше примере оценки учеников использовать для переменной quiz1 тип unsigned int?

Упражнение 4.27. Каков результат каждого из этих выражений?

unsigned long ul1 = 3, ul2 = 7;

(a) ul1 & ul2   (b) ul1 | ul2

(c) ul1 && ul2  (d) ul1 || ul2

4.9. Оператор sizeof

Оператор sizeof возвращает размер в байтах результата выражения или указанного по имени типа. Оператор имеет правосторонний порядок. Результат оператора sizeof — это константное выражение (см. раздел 2.4.4) типа size_t (см. раздел 3.5.2). Оператор существует в двух формах.

sizeof(тип)

sizeof выражение

Во второй форме оператор sizeof возвращает размер типа, возвращаемого выражением. Оператор sizeof необычен тем, что он не выполняет свой операнд.

Sales_data data, *p;

sizeof(Sales_data);  // размер, необходимый для хранения объекта

                     // типа Sales_item

sizeof data;         // размер типа данных, аналог sizeof(Sales_data)

sizeof p;            // размер указателя

sizeof *p;           // размер типа, на который указывает указатель p,

                     // т.е. sizeof(Sales_data)

sizeof data.revenue; // размер типа члена revenue класса Sales_data

sizeof Sales_data::revenue; // альтернативный способ получения

                            // размера revenue

Наиболее интересен пример sizeof *p. Во-первых, поскольку оператор sizeof имеет правосторонний порядок и тот же приоритет, что и оператор *, это выражение группируется справа налево. Таким образом, оно эквивалентно выражению sizeof(*p). Во-вторых, поскольку оператор sizeof не выполняет свой операнд, не имеет значения, допустим ли указатель p (т.е. инициализирован ли он) (см. раздел 2.3.2). Обращения к значению недопустимого указателя оператор sizeof не осуществляет, и указатель фактически не используется, поэтому он безопасен. Ему и не нужно обращаться к значению указателя, чтобы выяснить, какой тип он возвратит.

По новому стандарту для доступа к члену класса при получении его размера можно использовать оператор области видимости. Обычно к членам класса можно обратиться только через объект этого класса. Больше не обязательно предоставлять объект, так как оператор sizeof не обязан выбирать член класса, чтобы узнать его размер.