Бинарный сдвиг - не обнуляется значение после сдвигах всех битов

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

Миниатюры

 

0

PVD, потому что оператор >> вставляет слева старший бит. То есть когда там 1, то при сдвиге останется 1, если 0 то и будет 0. В Java есть оператор >>> (zero fill right shift). В C# такого нет поэтому делай как-то по другому. Например сначала сдвигаем на 1 бит и затем битовой маской сбрасываем старший бит. Тогда следующие операции сдвига будут уже добавлять 0 справа как тебе необходимо.

1

Да, уже сделал по другому, спасибо

0

Сообщение от OwenGlendower потому что оператор >> вставляет слева старший бит.

Надо заметить, что касается это только знаковых типов и называется знаковым расширением (sign extension)

Сообщение от PVD почему не обнуляется значение после сдвигах всех битов?

Давайте по порядку:

1. (uint)0xFFFFFFFF >> (byte)32
Касты в uint и в byte здесь ничего не делают: числовая константа, записанная в 16-м формате по умолчанию имеет тип uint или ulong, если значение больше, чем uint.MaxValue.
Так как uint является беззнаковым типом, то почему значения слева не обнуляются?
Потому что x >> 32 равносильно x >> 0, что оговорено в спецификации языка:

7.8 Shift operators Shift right: C# 1 2 3 4 int operator >>(int x, int count); uint operator >>(uint x, int count); long operator >>(long x, int count); ulong operator >>(ulong x, int count); When the type of x is int or uint, the shift count is given by the low-order five bits of count. In other words, the shift count is computed from count & 0x1F. When the type of x is long or ulong, the shift count is given by the low-order six bits of count. In other words, the shift count is computed from count & 0x3F.

Как видим, если сдвигается 32-битное число, то значение сдвига берется по маске 0x1F — это в двоичной системе 0001 1111.
Число 32 в двоичном представлении выглядит так: 0010 0000.

0010 0000₂
0001 1111₂
----------- AND
0000 0000₂

0xFFFFFFFF >> 0 = 0xFFFFFFFF.

2. (ulong)0xFFFFFFFF >> (byte)32
Здесь вы приводите беззнаковый 32-битный тип к беззнаковому 64-битному, значит знакового расширения нет и маска для значения сдвига равна 0x3F или 0011 1111

0010 0000₂
0011 1111₂
----------- AND
0010 0000₂ = 32₁₀

0x00000000FFFFFFFF >> 32 = 0x00000000000000

3. (int)0xFFFFFFFF >> (byte)32
Здесь та же ситуация, что в первом примере: сдвиг вправо 32-битного числа на 32 бита равносилен сдвигу вправо на 0 бит.

4. (long)0xFFFFFFFF >> (byte)32
Здесь та же ситуация, что во втором случае.
Надо только заметить, что записанное в шестнадцатеричном представлении число по умолчанию имеет беззнаковый тип (uint в данном случае), потому приведение его к большему, но знаковому типу, не приводит к знаковому расширению, следовательно значение (long)0xFFFFFFFF = 0x00000000FFFFFFFF.

0x00000000FFFFFFFF >> 32 = 0x0000000000000000

5. 0xFFFFFFFFFFFFFFFF >> 64
Снова ситуация, как во втором случае: тип ulong (нет знакового расширения) сдвигается вправо на 64 бита (0100 0000₂).
Применяем маску 0x3F:
0100 0000₂
0011 1111₂
----------- AND
0000 0000₂

В итоге этот сдвиг равносилен сдвигу на 0 бит вправо.

6. (byte)0xFF >> 8
Тут все просто: в выдержке из спека выше видно, что оператор сдвига вправо не определен для типа byte, потому значение конвертируется в ближайшее подходящее (int) и производится сдвиг на нем, то есть:
(byte)0xFF >> 8 = (int)0x000000FF >> 8 = 0

1

Ну а собственно, зачем зациклили сдвиг, это дает какие-то преимущества?

0

Сообщение от PVD зачем зациклили сдвиг

О каком зацикливании речь?

0

Сообщение от kolorotur О каком зацикливании речь?

Потому что x >> 32 равносильно x >> 0,

36 равносильно 4 и т.д.

0

PVD, не знаю, на MSDN висит вот такая отмазка:

The << operator masks expression2 to avoid shifting expression1 by too much. Otherwise, if the shift amount exceeded the number of bits in the data type of expression1, all the original bits would be shifted away to give a trivial result. To ensure that each shift leaves at least one of the original bits, the shift operators use the following formula to calculate the actual shift amount: mask expression2 (using the bitwise AND operator) with one less than the number of bits in expression1.

Подход, конечно, странный — "оставить хоть что-то".

0

Да, похоже защита от того, кто не знает, что пишет..

0