Побитовое исключающее или: Побитовые операторы

Содержание

PHP побитовые операторы

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

В наличии PHP есть 6 побитовых операторов:

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

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

Пример работы оператора «Побитовое И»:

Тоже самое только на примере PHP:


<?php

  $x = 3;         // ...0011
  $y = 5;         // ...0101

  echo $x & $y;   // ...0001 (1)

?>

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

Оператор | выполняет операцию логическое ИЛИ над каждым битом своих операндов. $y; // …0110 (6)

?>

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

Оператор ~ (побитовое НЕ) представляет собой унарный оператор, указываемый перед своим единственным операндом. Он выполняет инверсию всех битов операнда. Из-за способа представления целых со знаком в PHP применение оператора ~ к значению эквивалентно изменению его знака и вычитанию 1.

Пример работы оператора «Побитовое НЕ»:

Тоже самое только на примере PHP:


<?php

  $y = 5;     // ...0101

  echo ~$y;   // ...1010 (-6)

?>

Осталось рассмотреть два оператора — сдвиг влево и сдвиг вправо. Эти операторы можно использовать для быстрого умножения и деления (каждая позиция подразумевает «умножение/деление на 2»).

Сдвиг влево (<<)

Оператор << сдвигает все биты в первом операнде влево на количество позиций, указанное во втором операнде, который должен быть целым числом. Сдвиг значения влево на одну позицию эквивалентен умножению на 2, на две позиции — умножению на 4 и т.д.

Пример работы оператора «Сдвиг влево»:


<?php

  $y = 5;         // 000000101

  // тоже самое что и 5 * 4
  echo $y << 2;   // 000010100 (20)

?>

Сдвиг вправо (>>)

Оператор >> сдвигает все биты в первом операнде вправо на количество позиций, указанное во втором операнде, который должен быть целым числом. Сдвиг значения вправо на одну позицию эквивалентен делению на 2, на две позиции — делению на 4 и т.д.

Пример работы оператора «Сдвиг вправо»:


<?php

  $y = 20;         // 000010100

  // тоже самое что и 20 / 4
  echo $y >> 2;   // 000000101 (5)

?>

Помимо описанных операторов, в PHP также предусмотрены и сокращенные формы записи побитовых операторов.







Сокращенная запись побитовых операторов
Оператор Описание Пример Сокращенная форма записи
&= Присваивает левому операнду результат работы Побитового И $x = $x & $y $x &= $y
|= Присваивает левому операнду результат работы Побитового ИЛИ $x = $x | $y $x |= $y
^= Присваивает левому операнду результат работы Исключающего ИЛИ $x = $x ^ $y $x ^= $y
>>= Присваивает левому операнду результат работы оператора Сдвига вправо $x = $x >> 6 $x >>= 6
<<= Присваивает левому операнду результат работы оператора Сдвига влево $x = $x << 6 $x <<= 6

С этой темой смотрят:

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

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

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

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

Побитовое И в языке 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 в десятичной системе счисления. операнд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.

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

данные операции выполняются с высоким быстродействием, так как работа идет с целочисленными переменными. x могут быть заменены на 0 (самообратное свойство). И любой 0 может быть удален (потому что это личность).

Повторите как можно дольше. Любое число, которое появляется четное число раз, имеет целое число пар, поэтому все они становятся 0 и исчезают.

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

[Обновление]

Обратите внимание, что это доказательство требует только определенных предположений об операции. В частности, предположим, что множество S с оператором . имеет следующие свойства:

Ассоциативность: x . (y . z) = (x . y) . z для любого x, y и z в S.

Идентичность: существует единственный элемент e, такой что e . x = x . e = x для всех x в S.

Закрытие: Для любых x и y в S x . y также находится в S.

Самообратный: для любого x в S, x . x = e

Оказывается, нам не нужно предполагать коммутативность; мы можем доказать это:

(x . y) . (x . y) = e  (by self-inverse)
x . (y . x) . y = e (by associativity)
x . x . (y . x) . y . y = x . e . y  (multiply both sides by x on the left and y on the right)
y . x = x . y  (because x . x = y . y = e and the e's go away)

Теперь я сказал, что «вам не нужно ничего знать об отдельных битах». Я думал, что любой группе, удовлетворяющей этим свойствам, будет достаточно, и что такая группа не обязательно должна быть изоморфна целым числам в XOR.

Но @Steve Jessup доказал, что я не прав в комментариях. Если вы определяете скалярное умножение на {0,1} как:

0 * x = 0
1 * x = x

… тогда эта структура удовлетворяет всем аксиомам векторного пространства над целыми числами mod 2.

Таким образом, любая такая структура изоморфна набору векторов битов в компонентном XOR.

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

Что такое побитовые операторы?

Побитовые операторы — арифметическая операция, которая отвечает за побитовый сдвиг в PHP.

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

Для чего нужны побитовые операторы?

Побитовые операторы в PHP позволяют считывать и устанавливать конкретные биты целых чисел.

Синтаксис побитовых операторов

Синтаксис всех побитовых операторов представлен в таблице ниже.

Пример Название Результат
$a & $b И Устанавливаются только те биты, которые установлены и в $a, и в $b.
$a | $b Или Устанавливаются те биты, которые установлены в $a или в $b. являются строками, то операция будет выполнена над ASCII значениями символов, составляющих эти строки, и результатом будет строка. В других случаях, оба операнда будут приведены к целому и результатом будет тоже целое число.

Если операнд для оператора ~ является строкой, то операция будет произведена над ASCII значением символов, составляющих эту строку, и результатом будет строка. Иначе, и операнд и результат будут оперироваться как целые числа.

Метки: PHP, Операторы.

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

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

Например, в языке программирования Паскаль обычные логические операции и логические операции над битами обозначают с помощью одних и тех же ключевых слов: not, and, or, xor. Компилятор определяет, что имелось в виду в зависимости от контекста использования этих слов. Обычные логические операции объединяют два и более простых логических выражения. Например, (a > 0) and (c != b), (c < a) or(not b) и т.п. В свою очередь побитовые логические операции выполняются исключительно над целыми числами (или переменными, которые их содержат). Например, a and b, a or 8, not 247.

Как понять побитовые операции

1. Переведем пару произвольных целых чисел до 256 (один байт) в двоичное представление.

     6710 = 0100 00112
    11410 =  0111 00102

2. Теперь расположим биты второго числа под соответствующими битами первого и выполним обычные логические операции к цифрам, стоящим в одинаковых разрядах первого и второго числа. Например, если в последнем (младшем) разряде одного числа стоит 1, а другого числа — 0, то логическая операция and вернет 0, а or вернет 1. Операцию not применим только к первому числу.

3. Переведем результат в десятичную систему счисления.

    01000010 = 26 + 21 = 64 + 2 = 66
    01110011 = 26 + 25 + 24 + 21 + 20 = 64 + 32 + 16 + 2 + 1 = 115
    00110001 = 25 + 24 + 20 = 32 + 16 + 1 = 49
    10111100 = 27 + 25 + 24 + 23 + 22 = 128 + 32 + 16 + 8 + 4 = 188
    

4. Итак, в результате побитовых логических операций получилось следующее:

    67 and 114 = 66
    67 or 114 = 115
    67 xor 114 = 49
    not 67 = 188
    

Вот еще один пример выполнения логических операций над битами. Проверьте его правильность самостоятельно.

    5 and 6 = 4
    5 or 6 = 7
    5 xor 6 = 3
    not 5 = 250
    

Зачем нужны побитовые логические операции

Глядя на результат побитовых операций, не сразу можно уловить закономерности в их результате. Поэтому непонятно, зачем нужны такие операции. Однако, они находят свое применение. В байтах не всегда хранятся числа. Байт или ячейка памяти может хранить набор флагов (установлен — сброшен), представляющих собой информацию о состоянии чего-либо. С помощью битовых логических операций можно проверить, какие биты в байте установлены в единицу, можно обнулить биты или, наоборот, установить в единицу. Также существует возможность сменить значения битов на противоположные.

Проверка битов

Проверка битов осуществляется с помощью битовой логической операции and.

Представим, что имеется байт памяти с неизвестным нам содержимым. Известно, что логическая операция and возвращает 1, если только оба операнда содержат 1. Если к неизвестному числу применить побитовое логическое умножение (операцию and) на число 255 (что в двоичном представлении 1111 1111), то в результате мы получим неизвестное число. Обнулятся те единицы двоичного представления числа 255, которые будут умножены на разряды неизвестного числа, содержащие 0. Например, пусть неизвестное число 38 (0010 0110), тогда проверка битов будет выглядеть так:

Другими словами, x and 255 = x.

Обнуление битов

Чтобы обнулить какой-либо бит числа, нужно его логически умножить на 0.

Обратим внимание на следующее:

    1111 1110 = 254 = 255 - 1 = 255 - 20
    1111 1101 = 253 = 255 - 2 = 255 - 21
    1111 1011 = 251 = 255 - 4 = 255 - 22
    1111 0111 = 247 = 255 - 8 = 255 - 23
    1110 1111 = 239 = 255 - 16 = 255 - 24
    1101 1111 = 223 = 255 - 32 = 255 - 25
    1011 1111 = 191 = 255 - 64 = 255 - 26
    0111 1111 = 127 = 255 - 128 = 255 - 27

Т.е. чтобы обнулить четвертый с конца бит числа x, надо его логически умножить на 247 или на (255 — 23).

Установка битов в единицу

Для установки битов в единицу используется побитовая логическая операция or. Если мы логически сложим двоичное представление числа x с 0000 0000, то получим само число х. Но вот если мы в каком-нибудь бите второго слагаемого напишем единицу, то в результате в этом бите будет стоять единица.

Отметим также, что:

    0000 0001 = 20 = 1
    0000 0010 = 21 = 2
    0000 0100 = 22 = 4
    0000 1000 = 23 = 8
    0001 0000 = 24 = 16
    0010 0000 = 25 = 32
    0100 0000 = 26 = 64
    1000 0000 = 27 = 128
    

Поэтому, например, чтобы установить второй по старшинству бит числа x в единицу, надо его логически сложить с 64 (x or 64).

Смена значений битов

Для смены значений битов на противоположные используется битовая операция xor. Чтобы инвертировать определенный бит числа x, в такой же по разряду бит второго числа записывают единицу. Если же требуется инвертировать все биты числа x, то используют побитовую операцию исключающего ИЛИ (xor) с числом 255 (1111 1111).

Операции побитового циклического сдвига

Помимо побитовых логических операций во многих языках программирования предусмотрены битовые операции циклического сдвига влево или вправо. Например, в языке программирования Паскаль эти операции обозначаются shl(сдвиг влево) и shr (сдвиг вправо).

Первым операндом операций сдвига служит целое число, над которым выполняется операция. Во втором операнде указывается, на сколько позиций сдвигаются биты первого числа влево или вправо. Например, 105 shl 3 или 105 shr 4. Число 105 в двоичном представлении имеет вид 0110 1001.

При сдвиге влево теряются старшие биты исходного числа, на их место становятся младшие. Освободившиеся младшие разряды заполняются нулями.

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

Логические операции над числами

Логические операции над числами

12.7
Логические операции над числами

Логические операции в данном разделе в качестве аргументов требуют целых
чисел. Передача числа любого другого формата является ошибкой. Функции
обрабатывают целые числа, как если бы они были представлены в двух
системах счисления. FIXME
_____________________________________________

Заметка для реализации: Внутренне, конечно, реализация Common Lisp’а может
использовать и может и нет представление числа с дополнительным кодом. Все,
что необходимо это чтобы логические операции выполняли вычисление так, как
описано в разделе.

___________________________________________________________________________________________________________

Логические операции предоставляют удобный способ для представления
бесконечного вектора битов. Пусть такой концептуальный вектор будет
индексироваться с помощью неотрицательного целого. Тогда биту j
присваивается «вес (weight)» 2j. Предположим, что лишь конечное число
битов являются 1 или только конечное число битов являются 0. Вектор, у
которого конечное число битов 1, представлен как сумма всех весов этих
битов, и является положительным числом. Вектор, у которого конечное
число битов 0, представлен как -1 минус сумма всех весов этих битов, и
является отрицательным числом. FIXME

Данный метод использования целых чисел для представления битовых
векторов может в свою очередь использоваться для представления множеств.
Предположим, что некоторая (возможно бесконечная) совокупность
рассуждений для множеств отображается в неотрицательные целые числа.
FIXME Тогда множество может быть представлено как битовый вектор.
Элемент принадлежит множеству, если бит, индекс которого соответствует
элементу, является 1. Таким образом все конечные множества могут быть
представлены с помощью положительных целых, и множества, дополнения
которых конечны, с помощью отрицательных чисел. Функции logior, logand
и logxor, определённые ниже, вычисляют объединение, пересечение и

симметричную разность для таких множеств.

Функция возвращает побитовое логическое или для аргументов. Если не
задан ни один аргумент, возвращается ноль.


Функция возвращает побитовое логическое исключающее или для
аргументов. Если не задан ни один аргумент, возвращается ноль.


Функция возвращает побитовое логическое и для аргументов. Если ни
один аргумент не задан, возвращается ноль.


Функция возвращает побитовую логическую эквивалентность (также
известную как исключающее отрицающее или для аргументов. Если не задан
ни один аргумент, возвращается ноль.


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

(lognand n1 n2) ≡ (lognot (logand n1 n2))

(lognor n1 n2) ≡ (lognot (logior n1 n2))

(logandc1 n1 n2) ≡ (logand (lognot n1) n2)

(logandc2 n1 n2) ≡ (logand n1 (lognot n2))

(logorc1 n1 n2) ≡ (logior (lognot n1) n2)

(logorc2 n1 n2) ≡ (logior n1 (lognot n2))


В следующей таблице перечислены десять битовых логических операций
для двух целых чисел.

integer1 0 0 1 1
integer2 0 1 0 1 Имя операции
logand   0 0 0 1 и
logior   0 1 1 1 или
logxor   0 1 1 0 исключающее или
logeqv   1 0 0 1 эквивалентность (исключающее отрицающее или)
lognand  1 1 1 0 не и
lognor   1 0 0 0 не или
logandc1 0 1 0 0 не integer1 и integer2
logandc2 0 0 1 0 integer1 и не integer2
logorc1  1 1 0 1 не integer1 или integer2
logorc2  1 0 1 1 integer1 или не integer2






Функция boole принимает операцию op и два целых числа, и возвращает
целое число полученное применением операции op к этим двум числам.
Точные значения шестнадцати констант зависят от реализации, но
они подходят для использования в качестве первого аргумента для
boole:

integer1 0 0 1 1
integer2 0 1 0 1 Выполняемая операция
boole-clr   0 0 0 0 всегда 0
boole-set   1 1 1 1 всегда 1
boole-1     0 0 1 1 integer1
boole-2     0 1 0 1 integer2
boole-c1    1 1 0 0 дополнение integer1
boole-c2    1 0 1 0 дополнение integer2
boole-and   0 0 0 1 и
boole-ior   0 1 1 1 или
boole-xor   0 1 1 0 исключающее или
boole-eqv   1 0 0 1 эквивалентность (исключительное отрицающее или)
boole-nand  1 1 1 0 не и
boole-nor   1 0 0 0 не или
boole-andc1 0 1 0 0 не integer1 и integer2
boole-andc2 0 0 1 0 integer1 и не integer2
boole-orc1  1 1 0 1 не integer1 или integer2
boole-orc2  1 0 1 1 integer1 или не integer2






Таким образом boole может вычислять все шестнадцать логических
функций для двух аргументов. В целом,

(boole boole-and x y) ≡ (logand x y)

и далее по аналогии. boole полезна, когда необходимо параметризировать
процедуру так, что они может использовать одну из нескольких логических
операций.


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

(logbitp j (lognot x)) ≡ (not (logbitp j x))


logtest является предикатом, который истинен, если любой бит
определённый как 1 в integer1 также является соответствующим битом 1 в
integer2.

(logtest x y) ≡ (not (zerop (logand x y)))


Предикат logbitp является истиной, если бит в позиции index в целом
числе integer (то есть, его вес 2index), является 1, иначе предикат ложен.
Например:

(logbitp 2 6) is true

(logbitp 0 6) is false
(logbitp k n) ≡ (ldb-test (byte 1 k) n)

index

должен быть неотрицательным целым числом.


Если count положительное число, данная функция арифметически
сдвигает число integer влево на количество бит count. Если count
отрицательное число, функция сдвигает число integer вправо. Знак
результата всегда такое же как и исходного числа integer.

Говоря математически, эта операция выполняет вычисления
floor(integer ⋅ 2count).

Логически, функция перемещает все биты числа integer влево, добавляя
нулевые биты в конец, или вправо отбрасывая биты в конце числа. (В этом
контексте вопрос о том, что сдвигается налево, не относится к делу. Целые
числа, рассматриваемые как строки битов, являются «полубесконечными», то
есть концептуально расширяются бесконечно влево FIXME.) Например:

(logbitp j (ash n k)) ≡ (and (>= j k) (logbitp (- j k) n))


Функция возвращает количество бит в числе integer. Если integer
положительное число, тогда подсчитаны будут биты 1. Если число integer

отрицательно, то в два раза дополненной (two’s-complement) бинарной
форме будут подсчитаны биты 0. FIXME Результатом всегда является
неотрицательное целое число. Например:

(logcount 13) ⇒ 3      ;Бинарное представление …0001101

(logcount -13) ⇒ 2     ;Бинарное представление …1110011
(logcount 30) ⇒ 4      ;Бинарное представление …0011110
(logcount -30) ⇒ 4     ;Бинарное представление …1100010

Следующее тождество всегда верно:

(logcount x) ≡ (logcount (- (+ x 1)))

              ≡ (logcount (lognot x))


Данная функция выполняет следующие вычисления

ceiling(log 2(if integer < 0 then −integer else integer + 1))

Эта функция полезна в двух случаях. Первое, если целое число integer не
отрицательно, тогда его значение может быть представлено в беззнаковой
бинарной форме в поле, ширина которого в битах не меньше чем
(integer-length integer). Второе, независимо от знака числа integer, его
значение может быть представлено как знаковая бинарная два раза
дополненная (two’s-complement) форма в поле, ширина которого в битах
не меньше чем (+ (integer-length integer) 1). х можно заменить на 0 (самообратных собственность). И любой 0 могут быть удалены (потому что он личность).

Как долго можно повторять. Любое число, которое появляется четное число раз имеет цельное количество пар, так что все они становятся 0 и исчезают.

В итоге у вас остается только один элемент, который появляется нечетное число раз. Каждый раз, когда он появляется дважды, эти двое исчезли. В конечном итоге вы остались с одним явлением.

[обновление]

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

Assocativity: х . (г . З) = (х . г) . Z для любого Х, Y и Z В С.

Личность: существует единичный элемент е такой, что е . х = х . Е = Хдля всехX` в с.

Закрытие: для любого X и y В С `Х . г также В С.

Самообратных: для любого X В С Х . х = е

Как выясняется, нам не нужно предполагать, коммутативность, мы можем это доказать:

Теперь, я сказал, что «вам не нужно ничего знать об отдельных битов и». Я думаю, что любая группа, удовлетворяющая этих свойств было бы достаточно, и что такие группы не обязательно должны быть изоморфны целых чисел по операции XOR.

Но @Стив Джессап доказала, что я ошибался в комментариях. Если определить скалярное умножение на {0,1} как:

…тогда эта структура отвечает всем аксиомы векторного пространства за мод целых чисел 2.

Таким образом, любая такая структура изоморфна набор векторов битов под покомпонентно гаммирования.

, ) сравнивает каждый бит своего первого операнда с соответствующим битом своего второго операнда. Если бит в одном из операндов равен 0, а бит в другом операнде равен 1, соответствующий бит результата устанавливается в 1. В противном случае соответствующий бит результата устанавливается в 0.) (C ++ / CLI и C ++ / CX). . В C альтернативное написание предоставляется в виде макроса в заголовке . В C ++ альтернативное написание — ключевое слово; использование или его эквивалента в C ++ не рекомендуется. В Microsoft C ++ параметр компилятора / permissive- или / Za необходим для включения альтернативного написания.

Пример

  // expre_Bitwise_Exclusive_OR_Operator.cpp
// компилировать с помощью: / EHsc
// Продемонстрируем побитовое исключающее ИЛИ
#include 
используя пространство имен std;
int main () {
   беззнаковый короткий a = 0x5555; // шаблон 0101.б) << endl; // выводит шаблон "aaaa" 1010 ...
}
  

См. Также

Встроенные операторы C ++, приоритет и ассоциативность

Побитовая операция исключающее ИЛИ - онлайн-калькулятор

Операция двоичного исключающего ИЛИ битов двух целых чисел

Двоичная операция XOR

Эта функция выполняет побитовую операцию исключающего ИЛИ двух целых чисел.С помощью этой функции биты двух целых чисел объединяются двоичным исключающим ИЛИ.
Число можно вводить в шестнадцатеричном, десятичном, восьмеричном или двоичном формате.

Результат отображается в шестнадцатеричном, десятичном, восьмеричном и двоичном форматах.

Калькулятор побитовых операций XOR

Описание функции исключающего ИЛИ

Bitweise exklusive ODER, or kurz XOR Funktion, wird auf die Bitfolgen zweier ganzer Zahlen angewendet.Es wird die logische XOR-Operation auf jedem Paar korrespondierender Bits durchführt.
Das Ergebnisbit ist 1, Fall die zwei Bits unterschiedlich sind, und 0, drops sie gleich sind.

Функция побитового исключающего ИЛИ (XOR) применяется к битовым последовательностям двух целых чисел.
Биты одного числа подвергаются логической операции XOR с соответствующими битами другого числа.
Для каждой пары бит результирующий бит равен 0, если оба бита равны 0 или 1.Если один из обоих битов равен 1, бит результата устанавливается в 1.

Пример

В следующем примере биты двоичных чисел 11001100 и 11101 подвергаются операции XOR.
Результат 1010001.

Эта страница полезна?
да

Нет

Спасибо за ваш отзыв!

Извините за это

Как мы можем это улучшить?

послать


C ++ Tutorial => ^ - побитовое исключающее ИЛИ (исключающее ИЛИ)

Пример

  int a = 5; // 0101b (0x05)
int b = 9; // 1001b (0x09)
int c = a ^ b; // 1100b (0x0C)

std :: cout << "a =" << a << ", b =" << b << ", c =" << c << std :: endl;
  

Выход

a = 5, b = 9, c = 12

Почему

Побитовое XOR (исключающее ИЛИ) работает на битовом уровне и использует следующую логическую таблицу истинности:

  истина ИЛИ истина = ложь
истина ИЛИ ложь = истина
ложь ИЛИ ложь = ложь
  

Обратите внимание, что с операцией XOR true OR true = false , где, как и с операциями true AND / OR true = true , отсюда исключительный характер операции XOR. = Ь;

std :: cout << "a =" << a << ", b =" << b << "\ n";

Для производства вам нужно добавить чек, чтобы убедиться, что его можно использовать.c = ~ (a & c) & (a | c)

также в компиляторах 2015+ переменные могут быть назначены как двоичные:

  int cn = 0b0111;
  

Оператор XOR Python: побитовый оператор в Python

Оператор XOR

в Python также известен как « исключающий или », который сравнивает два двоичных числа побитово. между двумя значениями, чтобы выполнить побитовое « исключающее или » для их двоичных представлений. Например, при использовании между двумя целыми числами оператор XOR возвращает целое число.

Теперь давайте посмотрим на базовый обзор побитовых операторов в Python.

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

Побитовые операторы Python используются для выполнения побитовых вычислений над целыми числами. Сначала целые числа преобразуются в двоичный формат, а затем операции выполняются побитно, отсюда и название побитовые операторы.= b

print ('После замены:')
print ('Значение a:', a)
print ('Значение b:', b)

Выходные данные

 Значение a: 21
Значение b: 19
После замены:
Значение a: 19
Значение b: 21 

Вот и все.

См. Также

Python Division

Python Square

Python sftp

Python Modulo

Python rstrip

XOR - волшебный побитовый оператор

Магический побитовый оператор - XOR - предоставляет новые подходы, о существовании которых вы даже не подозревали для решения конкретной проблемы.) оператор. Чтобы решить эту проблему, вам необходимо знать свойство двоичного вычитания.

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

В этой статье мы обсудим магические возможности побитового оператора XOR.

XOR - действительно удивительный оператор. Вы даже представить себе не можете, что это позволяет нам делать. Прежде чем увидеть, что он может делать, давайте пересмотрим то, что мы, возможно, уже знаем об операторе.0011 = 0110 = 6

Это была основная информация о XOR. Теперь давайте посмотрим, какими магическими способностями обладает оператор XOR! Я хотел бы объяснить их, указав несколько проблем раньше, которые помогут вам ясно понять свойства.

Возвращает крайнюю правую единицу в двоичном представлении числа.

Пример: Для 1010 вы должны выполнить некоторые операции, чтобы на выходе получить 0010. Для 1100 вы должны указать 0100. Аналогично для 0001 вы должны вернуть 0001. (x & (x - 1))

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

(Если у вас есть опыт работы в сфере CS и вы понимаете все, что я говорил до сих пор, то поздравляю! Теперь вы уже знаете на 80% о мощной структуре данных под названием Fenwick Tree или Binary Indexed Tree. Вы можете посмотреть на это, чтобы узнать 20%, или дайте мне знать, если вы хотите, чтобы моя следующая статья была об этом.)

Интересно! не так ли? Давайте посмотрим еще на некоторые функции.

Для данного массива повторяющихся элементов ровно один элемент не повторяется. Вам нужно вернуть неповторяющийся элемент.arr [i] и сохраните результат в v для каждой итерации.Return v.

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

Напишите функцию для определения количества битов, необходимых для преобразования целого числа A в целое число B.

Ввод: 31, 14

Вывод: 2

Объяснение: У вас есть 31 (11111) и 14 (01110). Чтобы преобразовать 31 в 14, нам нужно перевернуть крайний левый бит и крайний правый бит 31.

Количество битов, необходимых для переворота, равно 2, поэтому мы возвращаем 2 в качестве ответа.

Входные данные: 12, 7

Выходные данные: 3

Я предлагаю вам попробовать реализовать это, прежде чем рассматривать решение ниже. Удачи!

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

Решение:

Связанные истории

Теги

Присоединяйтесь к хакеру Полдень