почему это работает? (находящий нечетное число в C++)

Он использует побитовый оператор «и» для маскировки всего, кроме последнего бита. Если последний бит равен 1, число нечетное. Этого объяснения достаточно?

Последний бит маскируется. Если вы посмотрите на каждое место в двоичном представлении числа (..., 256, 128, 64, 32, 16, 8, 4, 2 и 1), вы заметите, что нечетным является только одно место. Все остальные разряды имеют четное значение независимо от того, установлены ли биты или очищены (ноль является четным). А добавление четных чисел всегда дает четное число. Только последнее место определяет четность числа. Часть i & & 0x00000001 просто изолирует последнее место.

You are doing bitwise comparison. The if bit0 AND bit0 are both 1, then the answer's bit0 = 1.

Seeing that &0x00000001 is 1, any numbers with this bit are odd.

0x00000001 = 1
0x00000010 = 2
0x00000011 = 3
etc.

So, if you do a bitwise AND

00000001 AND 
00000001 = 
00000001 (same as true)

00000010 AND 
00000001 = 
00000000 (same as false)

00000011 AND 
00000001 = 
00000001 (same as true)

etc

Когда мы смотрим на числа в базе 10, легко определить, делится ли число на 10: в последней позиции у него 0. В приведенном выше коде также рассматривается цифра в последней позиции, но с основанием 2. Если она не равна нулю, число не делится на 2.

Odd numbers are all numbers of the form (2*n+1) where n is any integer (-2,-1,0,1....). So to find an odd number you have to see if the integer you're working with has that '+1' on it. When stored as an unsigned integer, a number can be expressed as the sum of powers of 2: 2^0 + 2^1 +2^2 + 2^4, etc. The binary version of the unsigned integer looks like a truth map of sorts: for every place there's a '1' in the binary number, add that power of two to the number. So, if you start at the right most digit in the binary representation of the unsigned integer and move left, each digit represents a power of two. If the digit is 1 then you add that power of two to the running sum and when you reach the end of the binary number.

Thus: 10001110b can be converted into an integer by summing the powers of two:

Rightmost: 2^1 + 2^2 + 2^3 + 2^7 :Leftmost = 141

The trick is that the rightmost digit represents 2^0. This is always 1. All the other digits represent even numbers. So, in terms of odd numbers you have to find the '+1'. That corresponds to the rightmost digit. All the other digits represent numbers of the form '2*n'. Therefore, to determine if a number of this format (unsigned integer) is odd you need only see if the right most bit is '1'.

The operation performed on the unsigned integer is a logical AND operation. Anything AND'd with 0 is 0, and 1 AND'd with 1 is 1. So the operation will cause all binary digits in the unsigned integer representation to be 0 except for the binary digit representing 2^0 (which is 1). So the unsigned integer binary representation will boil down to 0x00000001 if it's odd and 0x00000000 if it's even.

Note: When I write 0x00000000, the '0x' means that it's hexadecimal format. Each '0' represents four bits. So 0x00 is hexadecimal for 00000000b Written out in binary, the resulting possible unsigned integer binary representations after AND'ing the unsigned integer are:

00000000000000000000000000000000b == 0 and 00000000000000000000000000000001b == 1

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

Но, строго говоря, вам следует используйте (i% 2) или ((i% 2)! = 0) , чтобы определить, является ли i нечетным. Это будет работать независимо от представления отрицательных чисел, в то время как на машине с дополнением до единицы (-3 & 0x01) вернет ноль (ложный результат), даже если он явно нечетный.

Я понимаю, что машины, которые используют что-то другое, кроме двух. дополнение для представления отрицательного числа в настоящее время очень, очень редко, но также верно и то, что в наши дни компиляторы будут универсально компилировать (i% 2) для битового теста в любом случае. И помните, я обычно не следую своим советам, так что '

Например, как мы создаем двоичный эквивалент

8 4 2 1

0 0 0 0 = 0

0 0 0 1 = 1

0 0 1 0 = 2

0 0 1 1 = 3

Таким образом, вы можете увидеть любое нечетное число. LSB всегда установлен. То же, что и вы:)

Надеюсь, мой ответ ясен

Побитовый оператор И следует за этой таблицей истинности для каждого бита:
0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1

Поскольку компьютеры работают с числами с основанием 2, и каждый бит представляет собой степень двойки (1,2,4,8,16 ..),
младший бит представляет единственный нечетный число, независимо от того, насколько велико или мало значение, и независимо от того, подписано оно или нет. Поскольку результирующий бит устанавливается только в том случае, если оба операнда имеют этот бит, результат будет истинным тогда и только тогда, когда число нечетное.

Пример: 0b1110101 1 =
(1 * 2 ^ 0) + (1 * 2 ^ 1) + (0 * 2 ^ 2) + (1 * 2 ^ 3) +
(0 * 2 ^ 4) + (1 * 2 ^ 5) + (1 * 2 ^ 6) + (1 * 2 ^ 7) =
1 + 2 + 0 + 8 + 0 + 32 + 64 + 128 = 235
Без набора наименее значимых битов значение будет 234 и, следовательно, будет четным числом.