C shift right не работи правилно на типове int в моята програма

int е тип цяло число със знак. C11 6.5.7p4-5 казва следното:

4 Резултатът от E1 << E2 е E1 изместени наляво E2 битови позиции; освободените битове се запълват с нули. [...] Ако E1 има тип със знак и неотрицателна стойност и E1 x 2^E2 е представимо в типа резултат, тогава това е резултантната стойност; в противен случай поведението е недефинирано.

5 Резултатът от E1 >> E2 е E1 изместени надясно E2 битови позиции. [...] ако E1 има тип със знак и неотрицателна стойност, стойността на резултата е неразделна част от частното на E1 / 2^E2. Ако E1 има тип със знак и отрицателна стойност, получената стойност е дефинирана от внедряването.

Така в случая на <<, ако изместената стойност е отрицателна или положителната стойност след изместване не може да бъде представена в типа резултат (тук: int), поведението е недефинирано; в случай на >>, ако стойността е отрицателна, резултатът е дефинирана реализация.

Така и в двата случая ще получите резултати, които най-малкото зависят от внедряването, а в случай на ляво преместване, по-лошо, вероятно от нивото на оптимизация и други подобни. Една стриктно съответстваща програма не може да разчита на конкретно поведение.

Ако все пак искате да се насочите към конкретен компилатор, тогава проверете неговите ръководства за това какво би било поведението - ако е посочено такова - би било. Например GCC казва :

Резултатите от някои побитови операции върху цели числа със знак (C90 6.3, C99 и C11 6.5).

Побитовите оператори действат върху представянето на стойността, включително битовете за знак и стойност, където битът за знак се счита непосредствено над бита с най-висока стойност. Signed ‘>>’ действа върху отрицателни числа чрез знаково разширение. [*]

Като разширение на езика C, GCC не използва ширината, дадена в C99 и C11, само за да третира определени аспекти на знака „‹‹“ като недефинирани. Въпреки това, -fsanitize=shift (и -fsanitize =недефинирано) ще диагностицира такива случаи. Те също се диагностицират, когато се изискват постоянни изрази.

[*] разширението на знака тук означава, че знаковият бит - който е 1 за отрицателни цели числа, се повтаря от сумата на смяна, когато се изпълнява десен Shift - това е причината да видите тези Fs в резултата.

Освен това GCC винаги изисква допълващо представяне на 2, така че ако винаги използвате GCC, без значение към коя архитектура сте се насочили, това е поведението, което ще видите. Освен това в бъдеще някой може да използва друг компилатор за вашия код, като по този начин причини друго поведение там.

Може би бихте искали да използвате цели числа без знак - unsigned int или по-скоро, ако се очаква определена ширина, тогава например uint32_t, тъй като смените винаги са добре дефинирани за него и изглежда отговарят на вашите очаквания.

Друго нещо, което трябва да се отбележи, е, че не всички смени са разрешени. C11 6.5.7 p3:

[...]Ако стойността на десния операнд е отрицателна или е по-голяма или равна на ширината на повишения ляв операнд, поведението е недефинирано.

Така, ако някога преместите цяло число без знак с ширина 32 бита на 32 - наляво или надясно, поведението е недефинирано. Това трябва да се има предвид. Дори компилаторът да не направи нищо шантаво, някои процесорни архитектури действат така, сякаш изместването с 32 би изместило всички битове - други се държат така, сякаш стойността на изместването е 0.