Беззнаковая арифметика и целочисленное переполнение

unsigned long long x;
unsigned int y, z;

x = y*z;

На оценку выражения y*z не влияет контекст, в котором оно появляется. Он умножает два значения unsigned int, давая результат unsigned int. Если математический результат не может быть представлен в виде значения unsigned int, результат будет зациклен. Затем присваивание неявно преобразует (возможно, усеченный) результат из unsigned int в unsigned long long.

Если вы хотите, чтобы умножение давало результат unsigned long long, вам нужно явно преобразовать один или оба операнда:

x = (unsigned long long)y * z;

или, чтобы быть более явным:

x = (unsigned long long)y * (unsigned long long)z;

Оператор умножения * языка C применяется только к двум операндам одного типа. Из-за этого, когда вы даете ему операнды разных типов, они преобразуются в какой-то общий тип до того, как будет выполнено умножение. Правила могут быть немного сложными, когда вы смешиваете типы со знаком и без знака, но в этом случае, если вы умножаете unsigned long long на unsigned int, операнд unsigned int повышается до unsigned long long.

Если unsigned long long по крайней мере в два раза шире unsigned int, как в большинстве систем, то результат не будет переполняться или циклически повторяться, потому что, например, 64-битный unsigned long long может содержать результат умножение любых двух 32-битных значений unsigned int. Но если вы работаете в системе, где, например, int и long long имеют разрядность 64 бита, вы все равно можете использовать обход overflow, что даст вам результат в x, который не равен математическому произведению y и z.

Вы явно предполагаете, что unsigned int 32-битный, а unsigned long long 64-битный. Они не должны быть, допустим, это.

64-битный операнд, полученный путем преобразования 32-битного операнда, по-прежнему умещается в 32 бита. Таким образом, в y*(unsigned long long)z, где каждый из операндов сначала повышается до unsigned long long, результат вычисляется как unsigned long long и не может «переполняться», потому что это умножение двух квантификаторов, каждый из которых занимает 32 бита.

(Кроме того, в словаре стандарта C беззнаковые операции не «переполняются». Переполнение — это неопределенное поведение, при котором результат выходит за пределы целевого типа. Что делают беззнаковые операции, так это «обтекание»).

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

Это указано в стандартах C и C++. В стандарте С++ 11 (черновик n3337) говорится в пятой главе, оператор 9:

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

Есть пара страниц, описывающих все преобразования и прочее, что происходит, но это то, что определяет поведение этого конкретного выражения.