Сдвиг вправо с нулями в начале

Если вы явно указали shift 0xff, он работает так, как вы ожидали

cout << (0xff >> 3) << endl; // 31

Это должно быть возможно только в том случае, если 0xff в типе ширины со знаком 8 (char а также signed char на популярных платформах).

Итак, в общем случае:

Вам нужно использовать неподписанные целые

(unsigned type)0xff

сдвиг вправо работает как деление на 2 (с округлением вниз, если я правильно понимаю).

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

Два вида сдвига вправо, о которых вы говорите, называются Логический сдвиг а также Арифметический сдвиг. C и C ++ используют логическое смещение для целых чисел без знака, и большинство компиляторов будут использовать арифметическое смещение для целого числа со знаком, но это не гарантируется стандартным значением, означающим, что значение смещения вправо со знаком минус int определяется реализацией.

Поскольку вам нужен логический сдвиг, вам нужно переключиться на использование целого числа без знака. Вы можете сделать это, заменив свою константу на 0xffU,

Чтобы объяснить ваш реальный код, вам просто нужны версии цитат из стандарта C на языке C ++, которые Лундин дал в комментариях:

int number = ~0;
number = number << 4;

Неопределенное поведение. [expr.shift] говорит

Значение Е1 << E2 — E1-сдвинутые влево битовые позиции E2; освобождено
биты обнуляются. Если E1 имеет тип без знака, значение
результат E1 × 2^E2, уменьшено по модулю на единицу больше максимального значения
представимый в типе результата. Иначе, если E1 имеет подписанный тип
и неотрицательное значение, и E1 × 2^E2 представима в результате
тип, то это итоговое значение; в противном случае поведение
недеформированной определены.

number = ~0;
number = number >> 4;

Результат, определенный реализацией, в этом случае ваша реализация дала вам арифметический сдвиг:

Значение E1 >> E2 — это биты E2, сдвинутые вправо E1. Если E1 имеет
тип без знака или если E1 имеет тип со знаком и неотрицательное значение,
значение результата является неотъемлемой частью отношения
Е1 / 2^E2. Если E1 имеет тип со знаком и отрицательное значение, результирующий
значение определяется реализацией

Вы должны использовать тип без знака:

unsigned int number = -1;
number = number >> 4;
std::cout << std::hex << number << std::endl;

Выход:

0x0fffffff

Чтобы добавить мои 5 центов стоит здесь …
Я сталкиваюсь точно с той же проблемой, что и this.lau! Я провел некоторые поверхностные исследования по этому вопросу, и вот мои результаты:

typedef unsigned int Uint;
#define U31 0x7FFFFFFF
#define U32 0xFFFFFFFF

printf ("U31 right shifted: 0x%08x\n", (U31 >> 30));
printf ("U32 right shifted: 0x%08x\n", (U32 >> 30));

Output:
U31 right shifted: 0x00000001 (expected)
U32 right shifted: 0xffffffff (not expected)

Казалось бы (в отсутствие кого-либо с детальными знаниями), что компилятор C в XCode для Mac OS X v5.0.1 резервирует MSB как бит переноса, который вытягивается вместе с каждой сменой.

Немного досадно, но обратное НЕ верно:

#define ST00 0x00000001
#define ST01 0x00000002

printf ("ST00 left shifted: 0x%08x\n", (ST00 << 30));
printf ("ST01 left shifted: 0x%08x\n", (ST01 << 30));

Output:
ST00 left shifted: 0x40000000
ST01 left shifted: 0x80000000

Я полностью согласен с людьми выше, которые утверждают, что знак операнда не имеет никакого отношения к поведению оператора сдвига.

Кто-нибудь может пролить свет на спецификацию реализации C Posix4? Я чувствую, что окончательный ответ может быть там.

Между тем, похоже, что единственным обходным решением является конструкция по следующим направлениям:

#define CARD2UNIVERSE(c) (((c) == 32) ? 0xFFFFFFFF : (U31 >> (31 - (c))))

Это работает — раздражает, но необходимо.