Любопытная арифметическая ошибка- 255x256x256x256=18446744073692774400

 255*256*256*256

все операнды int вы переполняете int. Переполнение целого числа со знаком — это неопределенное поведение в C и C++.

ИЗМЕНИТЬ:

обратите внимание, что выражение 255 << 24 во втором объявлении также вызывает неопределенное поведение, если ваш тип int равен 32-bit. 255 x (2^24) — это 4278190080, которое не может быть представлено в виде 32-bit int (максимальное значение обычно равно 2147483647 на 32-bit int в дополнительном представлении до двух).

И C, и C++ говорят для E1 << E2, что если E1 имеет положительный тип со знаком и что E1 x (2^E2) не может быть представлено в типе E1, программа вызывает неопределенное поведение. Здесь ^ — математический оператор степени.

Ваши литералы int. Это означает, что все операции фактически выполняются на int и быстро переполняются. Это переполненное значение при преобразовании в 64-битное целое число без знака является значением, которое вы наблюдаете.

Возможно, стоит объяснить, что произошло, чтобы получить число 18446744073692774400. С технической точки зрения, написанные вами выражения вызывают «неопределенное поведение», и поэтому компилятор мог получить в результате что угодно; однако, предполагая, что int является 32-битным типом, что в настоящее время почти всегда так, вы получите тот же «неправильный» ответ, если напишете

uint64_t x = (int) (255u*256u*256u*256u);

и это выражение не вызывает неопределенное поведение. (Преобразование из unsigned int в int связано с поведением, определяемым реализацией, но поскольку за многие годы никто не создал ЦП с дополнением до единицы или процессором со знаком и величиной, все реализации, с которыми вы, вероятно, столкнетесь, точно определяют его. точно так же.) Я написал приведение в стиле C, потому что все, что я здесь говорю, в равной степени относится к C и C++.

Во-первых, давайте посмотрим на умножение. Я пишу правую часть в шестнадцатеричном формате, потому что так легче увидеть, что происходит.

255u * 256u               = 0x0000FF00u
255u * 256u * 256u        = 0x00FF0000u
255u * 256u * 256u * 256u = 0xFF000000u (= 4278190080)

Этот последний результат, 0xFF000000u, имеет старший бит набора 32-битных чисел. Следовательно, приведение этого значения к 32-битному типу signed приводит к тому, что оно становится отрицательным, как если бы из него было вычтено 2³² (это операция, определяемая реализацией, о которой я упоминал выше). ).

(int) (255u*256u*256u*256u) = 0xFF000000 = -16777216

Я пишу здесь шестнадцатеричное число без суффикса u, чтобы подчеркнуть, что битовый шаблон значения не меняется при преобразовании его в тип со знаком; это только переосмыслено.

Теперь, когда вы присваиваете -16777216 переменной uint64_t, она преобразуется обратно в беззнаковую как если бы путем добавления 2⁶⁴. (В отличие от преобразования без знака в знак, эта семантика предписана стандартом.) Это действительно изменяет битовый шаблон, устанавливая все старшие 32 бита числа в 1 вместо 0, когда вы ожидал:

(uint64_t) (int) (255u*256u*256u*256u) = 0xFFFFFFFFFF000000u

А если записать 0xFFFFFFFFFF000000 в десятичном виде, получится 18446744073692774400.

В качестве заключительного совета: всякий раз, когда вы получаете «невозможное» целое число из C или C++, попробуйте распечатать его в шестнадцатеричном формате; таким образом гораздо легче увидеть странности арифметики фиксированной ширины с дополнением до двух.

Ответ прост - переполнен.

Здесь произошло переполнение int, и когда вы назначаете его беззнаковому int64, оно преобразуется в 18446744073692774400 вместо 4278190080.