Побитовые операции

ВНИМАНИЕ, СТАТЬЯ НАХОДИТСЯ В РАЗРАБОТКЕ

Побитовые операции (англ. bitwise operations) — операции, производимые над цепочками битов. Выделяют два типа побитовых операций: логические операции и побитовые сдвиги.

Принцип работы

Логические побитовые операции

Битовые операторы И [math](AND, \&)[/math], ИЛИ [math](OR, \mid)[/math], НЕ [math](NOT, \sim)[/math] и исключающее ИЛИ [math](XOR,[/math] ^[math])[/math] используют те же таблицы истинности, что и их логические эквиваленты.

Побитовое И

Побитовое И используется для выключения битов. Любой бит, установленный в [math]0[/math], вызывает установку соответствующего бита результата также в [math]0[/math].

&
	11001010 11100010
	11000010

Побитовое ИЛИ

Побитовое ИЛИ используется для включения битов. Любой бит, установленный в [math]1[/math], вызывает установку соответствующего бита результата также в [math]1[/math].

|
	11001010 11100010
	11101010

Побитовое НЕ

Побитовое НЕ инвертирует состояние каждого бита исходной переменной.

~
	11001010
	00110101

Побитовое исключающее ИЛИ

Исключающее ИЛИ устанавливает значение бита результата в [math]1[/math], если значения в соответствующих битах исходных переменных различны.

^
	11001010 11100010
	00101000

Побитовые сдвиги

Операторы сдвига [math]\ll[/math] и [math]\gg[/math] сдвигают биты в переменной влево или вправо на указанное число. Сдвиг влево может применяться для умножения числа на два, сдвиг вправо — для деления. x = 7; //00000111

x << 1; //00001110

x << 5; //11000000

x >> 2; //00110000

Ограничения

C++ Visual Studio 15 Если выполняется сдвиг влево числа со знаком и при этом затрагивается бит знака, результат не определен. Результат сдвига вправо отрицательного числа со знаком зависит от реализации. Результат операции сдвига не определен, если число, на которое пользователь хочет сдвинуть биты имеет отрицательное значение или если оно больше или равно количеству битов в исходном числе.

1. include <iostream>
2. include <bitset>

using namespace std;

int main() {

   short short1 = 16384;    
   bitset<16> bitset1{short2};
   cout << bitset1 << endl;  // 0100000000000000 

   short short3 = short1 << 1;
   bitset<16> bitset3{short3};  // 16384 left-shifted by 1 = -32768
   cout << bitset3 << endl;  // 100000000000000 

   short short4 = short1 << 14;
   bitset<16> bitset4{short4};  // 4 left-shifted by 14 = 0
   cout << bitset4 << endl;  // 000000000000000  

}

Java В языке программирования Java существует также оператор беззнакового битового сдвига вправо [math]\gt \gt \gt [/math]. При использовании этого оператора на освободившиеся позиции всегда устанавливаются [math]0[/math], тогда как при использовании [math]\gt \gt [/math] на освободившиеся позиции устанавливается бит знака. При использовании битовых сдвигов есть некоторое отличие от целочисленного деления на [math]2[/math]: если сдвигать отрицательное число вправо, то сначала это аналогично целочисленному делению на [math]2[/math], но когда останется [math]-1[/math], то при следующих сдвигах результат меняться не будет. То есть происходит округление не к нулю, как при целочисленном делении, а к [math]-1[/math].

Нельзя сдвинуть число на количество бит большее, чем разрядность операнда. При этом происходит неявное сокращение правого (кол-во бит) операнда.

Примеры:

i 00000000000000000000000000000001 (1)
i<<29 00100000000000000000000000000000 (536870912)
i<<30 01000000000000000000000000000000 (1073741824)
i<<31 10000000000000000000000000000000 (-2147483648/2147483648)
i<<32 00000000000000000000000000000001 (1) i 11111111111111111111111111111111 (-1/4294967295)
i>>>1 01111111111111111111111111111111 (2147483647)
i>>>30 00000000000000000000000000000011 (3)
i>>>31 00000000000000000000000000000001 (1)
i>>>32 11111111111111111111111111111111 (-1/4294967295) i 11111111111111111111111101000000 (-192/4294967104)
i>>1 11111111111111111111111110100000 (-96/4294967200)
i>>30 11111111111111111111111111111111 (-1/4294967295)
i>>31 11111111111111111111111111111111 (-1/4294967295)
i>>32 11111111111111111111111101000000 (-192/4294967104)

Арифметическое распространение в Java проводится перед операциями и гарантирует расширение каждого операнда по крайней мере до int. Если же один из операндов long, то до long. Если сдвигаемая переменная по разрядности меньше, то результат будет не таким, как ожидалось. При приведении типов при расширении разрядности расширение происходит знаково. При сжатии разрядности просто отбрасываются лишние байты.

Примеры:

byte b = -127;
b 10000001 (-127/129)
(int)b 11111111 11111111 11111111 10000001 (-127/4294967169)
int i = -127;
i 11111111 11111111 11111111 10000001 (-127/4294967169)
(byte)i 10000001 (-127/129)
int i = 128;
i 00000000 00000000 00000000 10000000 (128)
(byte)i 10000000 (-128/128)
int i = 256;
i 00000000 00000000 00000001 00000000 (256)
(byte)i 00000000 (0)
int i = -256;
i 11111111 11111111 11111111 00000000 (-256/4294967040)
(byte)i 00000000 (0)


Применение для решения задач

• Проверка на то, является ли число степенью двойки

  Если выражение [math](x\ \&\ (x - 1))[/math] равно нулю, то число [math]x[/math] является степенью двойки [math](x \not= 0)[/math].

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

  Если выражение [math](x\ \&\ (x \ll 1))[/math] равно нулю, то в битовой записи числа [math]x[/math] нет двух единиц, идущих подряд.

• Номер младшего единичного бита

  Число, полученное в результате операции [math]x\ \&\ (\sim x + 1)[/math] будет равно номеру младшего единичного бита в числе [math]x[/math].

• Работа с битовыми масками

  Храним подмножества множества из [math]32, 64[/math] или [math]128[/math] фиксированных элементов. Значение каждого бита позволяет понять, включен элемент в множество или нет. Тогда легко сделать следующее: найти дополнение [math](\sim)[/math], пересечение [math](\&)[/math], объединение [math](\mid)[/math] множеств, установить бит по номеру [math](\mid 1 \ll x)[/math], снять бит по номеру [math](\& \sim(1 \ll x))[/math].

• Определение знака числа

sign = (v != 0) | -(int)((unsigned int)((int)v) >> (sizeof(int) * CHAR_BIT - 1)); // Or, for more speed but less portability: sign = (v != 0) | (v >> (sizeof(int) * CHAR_BIT - 1)); // -1, 0, or +1 // Or, for portability, brevity, and (perhaps) speed: sign = (v > 0) - (v < 0); // -1, 0, or +1

• Алгоритм Флойда

  Оптимизация с помощью битовых масок. Время работы [math]O\Big(\dfrac{n^3}{k}\Big)[/math].

• Дерево Фенвика

Источники информации

Онлайн справочник программиста на С и С++

MSDN: Операторы сдвигов влево и вправо

Битовые сдвиги и приведения в Java: подводные камни