Битовые операции

Побитовое И (&), Побитовое ИЛИ (|), Побитовое исключающее ИЛИ (^)

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

Описание и синтаксис

Побитовое И (&)

Побитовое И в языке C это одиночный амперсанд (&), используется между двух выражений. Побитовое И оперирует с каждым битом переменных по отдельности, руководствуся правилом - если оба бита перменных одного разряда равны 1, то результатом также будет 1 в данном разряде. В любом другом случае в результате получится ноль.

0 0 1 1 операнд1

0 1 0 1 операнд2

----------

0 0 0 1 (операнд & операнд2) - возвращаемый результат

В Arduino, тип данных int занимает 16-бит, поэтому использование & между двумя переменными типа int вызывает одновременное сравнение 16 бит. Рассмотрим этот код:

int a = 92; // в битовом виде: 0000000001011100

int b = 101; // в битовом виде: 0000000001100101

int c = a & b; // результат: 0000000001000100, или 68 в десятичной системе счисления.

Одним из мест применения побитового И является маскирование переменной для выделения какого-либо бита.

Побитовое ИЛИ (|)

Побитовое ИЛИ в языке C обозначается вертикальной чертой. Также как и & | работает с отдельными битами. Однако алгоритм его работы конечно же отличается. Побитовое ИЛИ вернет 1 в результате если хотя бы один из бит входных операндов будет равен 1.

0 0 1 1 операнд1

0 1 0 1 операнд2

----------

0 1 1 1 (операнд1 | операнд2) - возвращаемый результат

Пример:

int a = 92; // в битовом виде: 0000000001011100

int b = 101; // в битовом виде: 0000000001100101

int c = a | b; // результат: 0000000001111101, или 125 в десятичной системе счисления.

побитовое исключающее ИЛИ (^)

Данный оператор использует весьма редко в языке C. Побитовое исключающее ИЛИ работает по следующему принципу - Реузльтат будет 1, если только один из входных битов будет 1. В случае, если оба бита будут 1, то оператор возвращает 0.

0 0 1 1 операнд1

0 1 0 1 операнд2

----------

0 1 1 0 (операнд1 ^ операнд2) - возвращаемый результат

По другому алгоритм можно описать так - если биты различны, возвращается 1 и возвращается 0 если они одинаковы.

побитовый сдвиг влево (<<), побитовый сдвиг вправо(>>)

Описание:

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

Синтаксис:

переменная << число бит

переменная >> число бит

Параметры:

переменная - (byte, int, long) число <= 32

Пример:

int a = 5; // в битовом виде: 0000000000000101

int b = a << 3; // в битовом виде: 0000000000101000, или 40 в десятичной системе счисления

int c = b >> 3; // в битовом виде: 0000000000000101, или 5 с чего мы и начали

Вы можете легко потерять биты, слишком много сдвинув их влево:

int a = 5; // binary: 0000000000000101

int b = a << 14; // binary: 0100000000000000 - старшая 1 в 101 была потеряна

Самым простым способом применения операторов сдвига является нахождение степени числа 2.

1 << 0 == 1

1 << 1 == 2

1 << 2 == 4

1 << 3 == 8

...

1 << 8 == 256

1 << 9 == 512

1 << 10 == 1024

...

Если вы сдвигаете биты отрацительной переменной, то старший бит при сдвиге вправо копируется:

int x = -16; // binary: 1111111111110000

int y = x >> 3; // binary: 1111111111111110

Данный пример выдает не то что нам нужно. Чтобы старший бит не копировался, необходимо указать это:

int x = -16; // binary: 1111111111110000

int y = (unsigned int)x >> 3; // binary: 0001111111111110

Если вы осторожны в своих действиях, то можете применять сдвиг вправо для деления переменных на степень двойки.

Например:

int x = 1000;

int y = x >> 3; // целочисленное деление 1000 на 8, возвратит y = 125.

Советы программисту:

данные операции выполняются с высоким быстродействием, так как работа идет с целочисленными переменными. В результате умножение и деление на 2 выполняется едва ли не за 1 такт.

Побитовое НЕ (~)

Побитовое НЕ в C++ обозначается символом тильды ~. В отличие от & и |, побитовое НЕ не сравнивает биты, а просто инвертирует их. Все что было 1 становится 0 и наоборот, Например:

0 1 операнд1

----------

1 0 ~ операнд1

int a = 103; // binary: 0000000001100111

int b = ~a; // binary: 1111111110011000 = -104