Как работает побитовый оператор дополнения (~ tilde)?


почему ~2 равно -3? Как это ~ работа оператор?

12   153  

12 ответа:

помните, что отрицательные числа хранятся в виде два!--5--> позитивный аналог. В качестве примера, вот представление -2 в дополнении two: (8 бит)

1111 1110

способ получить это, взяв двоичное представление числа, взяв его дополнение (инвертируя все биты) и добавив один. Два начинается как 0000 0010, и путем инвертирования битов мы получаем 1111 1101. Добавление одного дает нам результат выше. Первый бит-это знаковый бит, намекая на негатив.

Итак, давайте посмотрим, как мы получаем ~2 = -3:

вот опять:

0000 0010

просто перевернуть все биты и мы получим:

1111 1101

Ну, как выглядит -3 В дополнение к двум? Начните с положительного 3: 0000 0011, переверните все биты до 1111 1100 и добавьте один, чтобы стать отрицательным значением (-3), 1111 1101.

поэтому, если вы просто инвертируете биты в 2, Вы получаете представление дополнения двух -3.

оператор дополнения ( ~ ) просто переворачивает биты. Это до машины, чтобы интерпретировать эти биты.

~ переворачивает биты в значении.

почему ~2 - это -3 имеет отношение к тому, как числа представлены побитово. Числа представлены в виде два.

Итак, 2-это двоичное значение

00000010

и ~2 переворачивает биты, так что значение теперь:

11111101

который является двоичным представлением -3.

как упоминали другие ~ просто перевернул биты (меняет один на ноль и ноль на один) и так как два!--10--> используется вы получите результат вы видели.

одна вещь, чтобы добавить почему используется дополнение two, это так, что операции с отрицательными числами будут такими же, как и с положительными числами. Подумайте о -3 как число к которому 3 должен быть добавлен для того, чтобы получить ноль, и вы увидите, что это число 1101 помните, что двоичное сложение так же, как начальная школа (десятичное) сложение только вы носите один, когда вы получаете два, а не 10.

 1101 +
 0011 // 3
    =
10000
    =
 0000 // lose carry bit because integers have a constant number of bits.
1101 и -3, переверните биты, которые вы получаете 0010 это два.

эта операция является дополнением, а не отрицанием.

считайте, что ~0 = -1, и работайте оттуда.

алгоритм отрицания - "дополнение, приращение".

знаете ли вы? Существует также "одно дополнение" , где обратные числа are симметричный, и он имеет как 0, так и -0.

int a=4; Система.из.println (~a); Результат будет :-5

' ~ ' любого целого числа в java представляет собой дополнение 1 к no. например, я беру ~4, что означает в двоичном представлении 0100. первый , длина целого числа составляет четыре байта,т. е. 4*8(8 бит на 1 байт)=32. Так что в системной памяти 4 представлено как 0000 0000 0000 0000 0000 0000 0000 0100 теперь оператор ~ будет выполнять Дополнение 1 на вышеуказанном двоичном no

i. e 1111 1111 1111 1111 1111 1111 1111 1111 1011->1 дополнения наиболее значимый бит представляет собой знак нет(либо-либо +) если это 1, то знак '-' если это 0, то знак '+' в соответствии с этим наш результат является отрицательным числом, в java отрицательные числа хранятся в форме дополнения 2, полученный результат мы должны преобразовать в дополнение 2( Сначала выполните Дополнение 1 и просто добавьте 1 к дополнению 1). все единицы станут нулями, кроме самого значимого бита 1(который является нашим знаковым представлением числа, что означает за оставшиеся 31 бит 1111 1111 1111 1111 1111 1111 1111 1011 (приобретенный результат ~ оператор) 1000 0000 0000 0000 0000 0000 0000 0100 (1 дополняют)

1 (2 дополнения)

1000 0000 0000 0000 0000 0000 0000 0101 теперь результат -5 проверьте эту ссылку для видео https://youtu.be/w4pJ4cGWe9Y

Я знаю, что ответ на этот вопрос размещен давно, но я хотел бы поделиться своим ответом на то же самое.

для нахождения дополнения одного числа сначала найдите его двоичный эквивалент. Вот, десятичное число 2 представлен 0000 0010 в двоичной форме. Теперь, взяв свое дополнение, инвертировав (перевернув все 1 в 0 и все 0 в 1) все цифры своего двоичного представления, что приведет к:

0000 0010 → 1111 1101

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

теперь, поскольку числа хранятся как дополнение 2 (принимая дополнение одного числа плюс один), поэтому для отображения этого двоичного числа,1111 1101, в десятичное число, сначала нам нужно найти его дополнение 2, который будет:

1111 1101 → 0000 0010 + 1 → 0000 0011

это дополнение 2-х. Десятичное представление двоичного числа, 0000 0011, составляет 3. И, поскольку знаковый бит был один, как упоминалось выше, поэтому результирующий ответ -3.

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

просто ...........

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

здесь N= ~N дают результаты - (N+1) всегда. Потому что система хранит данные в виде дополнения 2, что означает, что она хранит ~N так.

  ~N = -(~(~N)+1) =-(N+1). 

например:

  N = 10  = 1010
  Than ~N  = 0101
  so ~(~N) = 1010
  so ~(~N) +1 = 1011 

теперь точка, откуда приходит минус. Мое мнение заключается в том, что у нас есть 32-битный регистр, что означает 2^31 -1 бит, участвующий в операция и отдохнуть один бит, который изменяется в более раннем вычислении (дополнение) хранится как знаковый бит, который обычно равен 1. И мы получаем результат ~10 = -11.

~(-11) =10 ;

вышесказанное верно, если printf ("%d",~0); мы получаем результат: -1;

но printf ("%u",~0) чем результат: 4294967295 на 32-битной машине.


оператор побитового дополнения (~) является унарный оператора.

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

сначала он преобразует данное десятичное число в соответствующее ему binary значение.То есть в случае 2 он сначала преобразует 2 в 0000 0010 (до 8-битного двоичного числа).

затем он преобразует все 1 в число 0, а все нули в 1;тогда число станет 1111 1101.

это 2-х дополняют представление -3.

чтобы найти беззнаковое значение с помощью дополнения, т. е. просто преобразовать 1111 1101 в десятичное (=4294967293), мы можем просто использовать %u во время печати.

Я думаю, что для большинства людей путаница возникает из-за разницы между десятичным числом и двоичным числом со знаком, поэтому давайте сначала уточним:

для человеческого десятичного мира: 01 означает 1, -01 означает -1, для двоичного мира компьютера: 101 означает 5, если он не подписан. 101 означает (-4 + 1) Если подписано, в то время как подписанная цифра находится в позиции x. | x

Так 2 переметнулась бит = ~2 = ~(010) = 101 = -4 + 1 = -3 путаница возникает из-за смешивания подписанного результата (101=-3) и результат unsinged(101=5)

Сначала мы должны разделить данную цифру на ее двоичные цифры, а затем обратить ее, добавив в последнюю двоичную цифру.После этого выполнения мы должны дать противоположный знак предыдущей цифре, что мы находим complent ~2=-3 Объяснение: 2S двоичная форма 00000010 изменяется на 11111101 это те дополнения, затем дополняется 00000010+1=00000011 который является двоичной формой трех и со знаком т. е., -3

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

например ~2 приведет к -3.

Это связано с тем, что битовый оператор сначала представляет число в знаке и величине, которое равно 0000 0010 (8-битный оператор), где MSB-знаковый бит.

затем позже он будет принимать отрицательное число 2, которое равно -2.

-2 представлено как 1000 0010 (8 бит оператор) по знаку и величине.

позже он добавляет 1 к LSB (1000 0010 + 1), который дает вам 1000 0011.

Это -3.

Javascript tilde ( ~ ) приводит заданное значение в дополнение к одному-все биты инвертируются. Это все, что делает Тильда. Это не знак самоуверенности. Он не добавляет и не вычитает любое количество.

0 -> 1
1 -> 0
...in every bit position [0...integer nbr of bits - 1]

на стандартных настольных процессорах, использующих языки высокого уровня, такие как JavaScript, арифметика со знаком BASE10 является наиболее распространенной, но имейте в виду, что это не единственный вид. Биты на уровне ЦП подлежат интерпретации на основе ряда факторы. На уровне "кода", в данном случае JavaScript, они интерпретируются как 32-разрядное целое число со знаком по определению (оставим поплавки из этого). Подумайте об этом как о Кванте, эти 32 бита представляют собой множество возможных значений сразу. Это полностью зависит от преобразующего объектива, через который вы их просматриваете.

JavaScript Tilde operation (1's complement)

BASE2 lens
~0001 -> 1110  - end result of ~ bitwise operation

BASE10 Signed lens (typical JS implementation)
~1  -> -2 

BASE10 Unsigned lens 
~1  -> 14 

все вышеперечисленное верно одновременно.