# V6069\. Unsigned right shift assignment of negative 'byte' / 'short' value\.

Анализатор обнаружил случай, когда над возможно отрицательным числом типа 'byte' или 'short' применяется беззнаковый сдвиг вправо с присваиванием \(\>\>\>\=\)\. Результат такого сдвига может отличаться от ожидаемого\.

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

Также этот сдвиг можно совмещать со знаком равенства \(\>\>\>\=\)\. Однако при этом может возникнуть неочевидное поведение при использовании данного оператора с типами 'byte' или 'short'\. Проблема заключается в том, что они сначала будут неявно преобразованы к типу 'int' и сдвинуты вправо, а затем обрезаны при возвращении к исходному типу\. 

Если Вы попробуете скомпилировать код со следующим содержимым:

```cpp
void test(byte byteValue, boolean isFlag)
{
  ....
  if (isFlag)
  {
   byteValue = byteValue >>> 5;  
  }
  ....
}
```

, то получите ошибку:

```cpp
error: incompatible types:
       possible lossy conversion from int to byte
       byteValue = byteValue >>> 5;
                             ^
```

Это подтверждает вышесказанные слова о расширении до 'int', и далее компилятор не даст Вам присвоить 'int' к 'byte' без явного указания\. Это означает, что Вы знаете что делаете\.  Если скомпилировать тот же файл с небольшим исправлением:

```cpp
....
byteValue >>>= 5;
....
```

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

Из\-за этого в таком сдвиге с присвоением кроется поведение, которое может не ожидаться разработчиком\. В случае сдвига положительного числа будет работать так, как и ожидалось\. А что с отрицательным числом?

Давайте разберем синтетический случай, когда смещается с присвоением значение \-1 типа 'byte':

```cpp
byte byteValue = -1; // 0xFF or 0b1111_1111
byteValue >>>= 4;
assertTrue(byteValue == 0x0F); // byteValue == 0b0000_1111
```

Итак, разработчик думал, что у него есть 8 бит \(byte\), и, беззнаково смещая на 4 бита вправо, ожидает увидеть только 4 младших бита\. И тут на удивление разработчика 'assertTrue' не отрабатывает\!

Это происходит как раз из\-за того, что 'byteValue' неявно расширяется до 'int', сдвигается и обрезается до 'byte':

```cpp
byteValue == 0xFF (byte): 11111111
Расширение до 'int'     : 11111111 11111111 11111111 11111111
Смещение на 4           : 00001111 11111111 11111111 11111111
Преобразование в 'byte' : 11111111
```

По завершении операции может сложиться ощущение, что беззнаковый сдвиг \(\>\>\>\=\) работает некорректно\. Но всё логично и правильно\. Просто существует нюанс, который следует учитывать при работе с типами 'byte' или 'short'\.