(10010011) & (00111101) == (00010001)
потому что только четвертый и первый разряды обоих операндов содержат 1.
| : Поразрядное ИЛИ
Эта бинарная операция сравнивает последовательно разряд за разрядом два операнда. Для каждого разряда результат равен 1, если любой из соответствующих разрядов операндов равен 1. [В терминах "истинно-ложно" результат получается истинным, если один из двух (или оба) одноразрядных операндов является истинным.] Так,
(10010011) | (00111101) == (10111111)
потому что все разряды, кроме шестого, в одном из двух операндов имеют значение 1.
^: Поразрядное исключающее ИЛИ
Эта бинарная операция сравнивает последовательно разряд за разрядом два операнда. Для каждого разряда результат равен 1, если один нз двух (но не оба) соответствующих разрядов операндов равен 1. [В терминах "истинно-ложно" результат получается истинным, если один из двух (но не оба) одноразрядных операндов является истинным.] Поэтому
(10010011) ^ (00111101) == (10101110)
Заметим, что, поскольку нулевой разряд в обоих операндах имеет значение 1, нулевой разряд результата имеет значение 0.
Применение
Описанные выше операции часто используются для установки некоторых разрядов, причем другие разряды остаются неизменными. Например, предположим, что мы определили MASK в директиве #define MASK, равным 2, т. е. двоичному значению 00000010, имеющему ненулевое значение только в первом разряде. Тогда оператор
flags = flags & MASK;
установит все разряды flags (кроме первого) в 0, потому что любое значение разряда при выполнении операции. & дает 0, если разряд второго операнда равен 0. Однако первый разряд останется неизменным. (Если первый разряд операнда содержит 1, то результат операции 1 & 1 равен 1, а если первый разряд имеет значение 0, то 0 & 1 будет равно 0.) Аналогично оператор
flags = flags | MASK;
установит первый разряд в 1 и оставит все остальные разряды неизменными. Это происходит потому, что любое значение разряда при выполнении операции 1, если разряд второго операнда равен нулю, остается без изменения, а если разряд второго операнда равен 1, то первый разряд результата будет иметь значение 1.
Поразрядные операции сдвига
Эти операции сдвигают разряды влево или вправо. Мы снова запишем двоичные числа в явной форме, чтобы подробно показать механизм сдвига.
&& : Сдвиг влево
Эта операция сдвигает разряды левого операнда влево на число позиций, указанное правым операндом. Освобождающиеся позиции заполняются нулями, а разряды, сдвигаемые за левый предел левого операнда, теряются. Поэтому
(10001010) << 2 == 00101000
где каждый разряд сдвинулся на две позиции влево.
>> : Сдвиг вправо
Эта операция сдвигает разряды левого операнда вправо на число позиций, указанное правым операндом. Разряды, сдвигаемые за правый предел левого операнда, теряются. Для чисел типа unsigned позиции, освобождающиеся слева, заполняются нулями. Для чисел со знаком результат зависит от типа ЭВМ. Освобождающиеся позиции могут заполняться нулями или значением знакового разряда (самого левого). Для значений без знака имеем
(10001010) >> 2 == (00100010)
где каждый разряд переместился на две позиции вправо.
Применение
Эти операции выполняют сдвиг, а также эффективное умножение и деление на степени 2:
number << n умножает number на 2 в n-й степени
number >> n делит number на 2 в n-й степени, если число неотрицательное.
Это аналогично соответствующему алгоритму для десятичной системы счисления, обеспечивающему сдвиг десятичной точки при умножении или делении на 10.
Поля
Второй способ манипуляции разрядами заключается в использовании поля. Полем считается последовательность соседних разрядов в числе типа int или unsigned int. Поле устанавливается при помощи определения структуры, в котором помечается каждое поле и определяется его размер. Следующее описание устанавливает четыре 1-разрядных поля:
struct {
unsigned autfd: 1;
unsigned bldfc: 1;
unsigned undln: 1;
unsigned itals: 1;
} prnt;
Переменная prnt содержит теперь четыре 1-разрядных ноля. Обычную операцию принадлежности элемента структуры можно использовать для присвоения значении отдельным полям:
prnt.itals = 0;
prnt.undln = 1;
Поскольку каждое поле состоит только из одного разряда, мы можем использовать для присваивания лишь значение 0 или 1.
Переменная prnt запоминается в ячейке памяти, имеющей размер, равный длине числа типа int, но для нашего примера используется только четыре разряда.
Размер поля не ограничивается одним разрядом. Мы можем делать, например, так:
struct {
unsigned code1 : 2;
unsigned code2 : 2;
unsigned code3 : 8;
} prcode;
Таким путем создаются два 2-разрядных поля и одно 8-разрядное. Мы можем выполнять присваивания, подобные следующим:
prcode.code1 = 0;
prcode.code2 = 3;
prcode.code3 = 102;
Удостоверьтесь только, что значение нe превышает размер поля.
Что произойдет, если общее число объявленных вами разрядов превысит размер переменной типа int? В этом случае используется следующая ячейка памяти типа int. Одиночное поле не может перекрывать границу между двумя int, компилятор автоматически сдвигает определение перекрывающего поля таким образом, чтобы данное поле было выравнено по границе int. Если это происходит, он оставляет в первом int безымянное "пустое место".
Вы можете заполнить структуру поля с безымянными пустыми местами, используя поле без имени. Применение поля без имени с размером 0 выравнивает очередное поле по границе следующего целого:
struct {
field1 : 1;
: 2;
field2 : 1;
: 0;
field3 : 1; } stuff;
Здесь есть 2-разрядный промежуток между stuff.field1 и stuff.field2, a stuff.field3 запоминается в следующем int.
Порядок размещения полей в int зависит от типа ЭВМ. В одних машинах поля располагаются слева направо, в других - справа налево.