Почему побайтовый сдвиг даёт разные результаты?

Question

[Pashka23]

Пытаюсь выполнить одинаковые операции сдвига над одной и той же переменной:

int main() {
	char index = 33;
	char enc = index << 2 >> 2;
	std::cout << (int)enc << std::endl;

	enc = index << 2;
	enc = enc >> 2;
	std::cout << (int)enc << std::endl;
}

, но получаю разный результат:

33
-31

Не могу понять почему результат разный и откуда взялось значение -31?

Comments

[Евгений Шатунов]

Pashka23 , запиши сюда шестнадцатеричное и бинарное представления числа 33.
Начнем с этого.

Answer 1

[res2001]

Читайте тут до прояснения раздел "Bitwise shift operator.
Смысл в том, что если вы знаковое число сдвинули влево так, что старшим разрядом стала 1, то в результате получится отрицательное число. При сдвиге вправо знакового числа, освобождающиеся слева разряды заполняются битом знака (а не нулем), поэтому результат сдвига отрицательного числа так же будет отрицательным (а положительного - положительным:). Если сдвигать вправо беззнаковое число, то свободные биты будут всегда заполнятся нулями.
Кстати, на сколько помню, по стандарту знаковость char не определена (может быть как знаковым так и беззнаковым). Вам с вашим примером не повезло, char оказался знаковым. Зато это дало возможность немного глубже понять сдвиги.

Comments

[Евгений Шатунов]

Там еще есть один нюанс.
Сдвиг 0b00100001 влево на два бита приведет к переполнению знакового после его приведения обратно к char. А это - UB.

[res2001]

Евгений Шатунов, Не думаю, что это UB:

For signed and non-negative a, if a * 2^b
is representable in the unsigned version of the return type, then that value, converted to signed, is the value of a << b (this makes it legal to create INT_MIN as 1<<31); otherwise the behavior is undefined.

[Евгений Шатунов]

res2001, все так. Однако очень важно обратить внимание на стандарт, с которым код транслируется.
Так, например, для C++11 ограничение будет таким [5.8.2 - expr.shift]:

Otherwise, if E1 has a signed type and non-negative value, and E1 × 2^E2 is representable in the result type, then that is the resulting value; otherwise, the behavior is undefined.

Для C++14 и C++17 ограничение будет уже таким [5.8.2 - expr.shift]:

Otherwise, if E1 has a signed type and non-negative value, and E1 × 2^E2 is representable in the corresponding unsigned type of the result type, then that value, converted to the result type, is the resulting value; otherwise, the behavior is undefined.

А для C++20 - уже таким [7.6.7 - expr.shift]:

The value of E1 << E2 is the unique value congruent to E1 × 2^E2 modulo 2^N , where N is the width of the type of the result. [Note: E1 is left-shifted E2 bit positions; vacated bits are zero-filled. — end note]

В общем смысле я бы склонялся к тому, что там UB. Изначально в своем мнении я опирался на статью от авторов PVS-Studio.

[res2001]

Евгений Шатунов, Спасибо за ссылки. В стандартах в общем то все +-одинаково. В С++20 изменили формулировку, но смысл, по моему тот же самый, даже несколько упростили, что странно :)
Прочитал статью, там UB только при использовании отрицательных значений.
Таким образом, в нашем примере сдвиг влево это не UB, но его результат будет отрицательным, и тогда уже UB - это следующий сдвиг вправо. Хотя тут в ассемблере - "арифметический сдвиг" с вполне понятным результатом для отрицательных чисел. Но с точки зрения стандартов С++ все сдвиги с отрицательными операндами UB.

[Евгений Шатунов]

res2001, в C++20 по сдвигам варианты UB вообще подрезали, что меня лично только радует. Теперь поведение кода станет более интуитивным.

А в остальном, я только сейчас увидел что ошибся со ссылками и цитатой на стандарт C++11. Сейчас там исправил. Продублирую цитату и сюда тоже.

Otherwise, if E1 has a signed type and non-negative value, and E1 × 2^E2 is representable in the result type, then that is the resulting value; otherwise, the behavior is undefined.

Между C++11 и C++14, выходит, разница в том, в беззнаковом или знаковом типе должно быть представимо значение результата сдвига.

[res2001]

Евгений Шатунов, В С++20 убрали все рассуждения о знаковом/беззнаковом типе, за исключением UB, когда правый операнд отрицательный . Я так понимаю, что теперь левый сдвиг будет выполняться как для беззнаковых типов, затем битовый результат сдвига интерпретируется в результирующий тип.
Интересно, реально компиляторы как-то меняли свое поведение при сдвигах от стандарта к стандарту. Что-то мне кажется, что нет. В стандартах формулировки потихоньку подгоняли под реальное положение дел. Пожалуй в С++20 формулировка стала наиболее адекватной.

Answer 2

[galaxy]

Привет от integer promotion. Поэтапно с типами:

#include <iostream>
using namespace std;

int main() {

    char index = 33;
    auto c1 = index << 2;
    auto c2 = c1 >> 2;
    cout << typeid(c1).name() << " " << c1 << endl;
    cout << typeid(c2).name() << " " << c2 << endl;

    char enc;
    enc = index << 2;
    cout << "enc: " << (int)enc << endl;
    enc = enc >> 2;
    cout << "enc: " << (int)enc << endl;

    return 0;
}

Почему 33 << 2 дало отрицательное число в signed char, думаю, не надо объяснять?

Comments

[galaxy]

Евгений Шатунов, упс...

[Евгений Шатунов]

galaxy, все в порядке. Потрем историю для красоты. :)
А вот по поводу получения отрицательного числа, я сомневаюсь что автор догадается как там получился UB, который в этот раз и чисто случайно сделал ему отрицательное.
Ведь в результате его операций произошло переполнение знакового.

[Pashka23]

Евгений Шатунов, автор "не догадался" только почему из 10000100 >> 2 получилось 11100001.

[Евгений Шатунов]

Pashka23, а это хорошо объясняется у res2001 , за что я бы лично и его ответ тоже продвинул в решение.

[Pashka23]

Евгений Шатунов, да, я тоже умею читать и уже отметил это решением.