Операторы смещения бита делают точно, что подразумевает их имя. Они смещают биты. Вот является резюме (или not-so-brief) введением в различные операторы сдвига.

Операторы

• >> арифметика (или подписанный) оператор сдвига вправо.
• >>> логическое (или неподписанный) оператор сдвига вправо.
• << левый оператор смещения и удовлетворяет потребности и логических и арифметических сдвигов.

Все эти операторы могут быть применены к целочисленным значениям (int, long, возможно short и byte или char). На некоторых языках, применяя операторы сдвига к любому типу данных, меньшему, чем [1 119] автоматически, изменяет размеры операнда, чтобы быть int.

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

Также примечание, что C и C++ не различают операторы сдвига вправо . Они обеспечивают только >> оператор, и смещающее право поведение является реализацией, определенной для типов со знаком. Остальная часть ответа использует операторы C# / Java.

(Во всей господствующей тенденции C и реализациях C++ включая gcc и clang/LLVM, >> на типах со знаком арифметика. Некоторый код принимает это, но это не что-то стандартные гарантии. Это не не определено , хотя; стандарт требует, чтобы реализации определили его так или иначе. Однако сдвиги влево отрицательных чисел со знаком неопределенное поведение (переполнение целого числа со знаком). Таким образом, если Вам не нужен арифметический сдвиг вправо, это обычно - хорошая идея сделать Ваше смещение бита с неподписанными типами.)

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

Целые числа хранятся, в памяти, как ряд битов. Например, номер 6, сохраненный как 32-разрядное int, был бы:

00000000 00000000 00000000 00000110

Смещение этой комбинации двоичных разрядов налево одно положение (6 << 1) привело бы к номеру 12:

00000000 00000000 00000000 00001100

, Как Вы видите, цифры сместились налево одним положением, и последняя цифра справа заполнена нулем. Вы могли бы также отметить, что оставленное смещение эквивалентно умножению полномочиями 2. Так 6 << 1 эквивалентно [1 127], и 6 << 3 эквивалентно [1 129]. Хороший оптимизирующий компилятор заменит умножение сдвигами, если это возможно.

Непроспект, смещающийся

Обратите внимание на то, что, это не циклические сдвиги. Смещение этого значения налево одним положением (3,758,096,384 << 1):

11100000 00000000 00000000 00000000

результаты в 3,221,225,472:

11000000 00000000 00000000 00000000

цифра, которая смещается "от конца", потеряна. Это не повторяется.

Логический сдвиг вправо (>>>)

А логический сдвиг вправо является обратным к сдвигу влево. Вместо движущихся битов налево, они просто перемещаются направо. Например, смещение номера 12:

00000000 00000000 00000000 00001100

направо одним положением (12 >>> 1) возвратит наш оригинал 6:

00000000 00000000 00000000 00000110

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

Потерянные биты уводят

Однако, сдвиг не может исправить "потерянные" биты. Например, если мы смещаем этот шаблон:

00111000 00000000 00000000 00000110

левым 4 положения (939,524,102 << 4), мы добираемся 2,147,483,744:

10000000 00000000 00000000 01100000

и затем смещающийся назад ((939,524,102 << 4) >>> 4) мы добираемся 134,217,734:

00001000 00000000 00000000 00000110

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

Арифметический сдвиг вправо (>>)

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

, Например, если мы интерпретируем эту комбинацию двоичных разрядов как отрицательное число:

10000000 00000000 00000000 01100000

у нас есть номер-2 147 483 552. Смещение этого к правильным 4 позициям с арифметическим сдвигом (-2 147 483 552>> 4) дал бы нам:

11111000 00000000 00000000 00000110

или номер-134 217 722.

, Таким образом, мы видим, что сохранили знак наших отрицательных чисел при помощи арифметического сдвига вправо, а не логического сдвига вправо. И еще раз, мы видим, что выполняем подразделение полномочиями 2.