Преобразование подписи в беззнаковое на C - это всегда безопасно?

Краткий ответ

Ваш i будет преобразованный к целому числу без знака, добавив UINT_MAX + 1, затем добавление будет выполнено с беззнаковыми значениями, что приведет к большому result (в зависимости от значений u и i).

Длинный ответ

Согласно стандарту C99:

6.3.1.8 Usual arithmetic conversions

1. If both operands have the same type, then no further conversion is needed.
2. Otherwise, if both operands have signed integer types or both have unsigned integer types, the operand with the type of lesser integer conversion rank is converted to the type of the operand with greater rank.
3. Otherwise, if the operand that has unsigned integer type has rank greater or equal to the rank of the type of the other operand, then the operand with signed integer type is converted to the type of the operand with unsigned integer type.
4. Otherwise, if the type of the operand with signed integer type can represent all of the values of the type of the operand with unsigned integer type, then the operand with unsigned integer type is converted to the type of the operand with signed integer type.
5. Otherwise, both operands are converted to the unsigned integer type corresponding to the type of the operand with signed integer type.

В вашем случае у нас есть один беззнаковый int (u) и подписанный int (i). Ссылаясь на (3) выше, поскольку оба операнда имеют одинаковый ранг, ваш i должен быть преобразованный для целого числа без знака.

6.3.1.3 Signed and unsigned integers

1. When a value with integer type is converted to another integer type other than _Bool, if the value can be represented by the new type, it is unchanged.
2. Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or subtracting one more than the maximum value that can be represented in the new type until the value is in the range of the new type.
3. Otherwise, the new type is signed and the value cannot be represented in it; either the result is implementation-defined or an implementation-defined signal is raised.

Теперь нам нужно обратиться к (2) выше. Ваш i будет преобразован в беззнаковое значение путем добавления UINT_MAX + 1. Таким образом, результат будет зависеть от того, как UINT_MAX определен в вашей реализации. Он будет большим, но не переполниться, потому что:

6.2.5 (9)

A computation involving unsigned operands can never overflow, because a result that cannot be represented by the resulting unsigned integer type is reduced modulo the number that is one greater than the largest value that can be represented by the resulting type.

Бонус: арифметическое преобразование Semi-WTF

#include <stdio.h>

int main(void)
{
  unsigned int plus_one = 1;
  int minus_one = -1;

  if (plus_one < minus_one)
    printf("1 < -1");
  else
    printf("boring");

  return 0;
}

Вы можете использовать эту ссылку, чтобы попробовать это в Интернете: https://repl.it/repls/QuickWhimsicalBytes

Бонус: побочный эффект арифметического преобразования

Правила арифметического преобразования могут использоваться для получения значения UINT_MAX путем инициализации беззнакового значения значением -1, то есть:

unsigned int umax = -1; // umax set to UINT_MAX

Это гарантирует переносимость независимо от представления числа со знаком в системе из-за правил преобразования, описанных выше. См. Этот вопрос SO для получения дополнительной информации: Безопасно ли использовать -1, чтобы установить все биты в истинное значение?

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

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

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

Как уже было сказано ранее, вы можете без проблем выполнять переход между подписанными и неподписанными. Граница для целых чисел со знаком - -1 (0xFFFFFFFF). Попробуйте сложить и вычесть из этого, и вы обнаружите, что можете отбросить назад, и это будет правильно.

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

int iValue, iResult;
unsigned int uValue, uResult;

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

Ссылаясь на Библия:

• Ваша операция сложения приводит к преобразованию int в беззнаковое int.
• Предполагая, что представление дополнения до двух и типы одинакового размера, битовая комбинация не меняется.
• Преобразование беззнакового int в подписанное int зависит от реализации. (Но в наши дни это, вероятно, работает так, как вы ожидаете, на большинстве платформ.)
• Правила немного усложняются в случае объединения подписанных и неподписанных разных размеров.

Преобразование из подписанного в беззнаковый не обязательно ли нет просто копирует или переинтерпретирует представление подписанного значения. Цитата из стандарта C (C99 6.3.1.3):

When a value with integer type is converted to another integer type other than _Bool, if the value can be represented by the new type, it is unchanged.

Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or subtracting one more than the maximum value that can be represented in the new type until the value is in the range of the new type.

Otherwise, the new type is signed and the value cannot be represented in it; either the result is implementation-defined or an implementation-defined signal is raised.

Для представления дополнения до двух, которое в наши дни почти универсально, правила действительно соответствуют переинтерпретации битов. Но для других представлений (знак и величина или дополнение до единиц) реализация C должна по-прежнему обеспечивать тот же результат, что означает, что преобразование не может просто копировать биты. Например, (беззнаковый) -1 == UINT_MAX, независимо от представления.

В общем, преобразования в C определены для работы со значениями, а не с представлениями.

Чтобы ответить на исходный вопрос:

unsigned int u = 1234;
int i = -5678;

unsigned int result = u + i;

Значение i преобразуется в целое число без знака, в результате чего получается UINT_MAX + 1 - 5678. Затем это значение добавляется к беззнаковому значению 1234, получая UINT_MAX + 1 - 4444.

(В отличие от беззнакового переполнения, подписанное переполнение вызывает неопределенное поведение. Обертывание является обычным явлением, но не гарантируется стандартом C - и оптимизация компилятора может нанести ущерб коду, который делает необоснованные предположения.)

Ужасные ответы в изобилии

Озгур Озчитак

When you cast from signed to unsigned (and vice versa) the internal representation of the number does not change. What changes is how the compiler interprets the sign bit.

Это совершенно неверно.

Матс Фредрикссон

When one unsigned and one signed variable are added (or any binary operation) both are implicitly converted to unsigned, which would in this case result in a huge result.

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

smh

Your addition operation causes the int to be converted to an unsigned int.

Неправильный. Может быть, есть, а может, и нет.

Conversion from unsigned int to signed int is implementation dependent. (But it probably works the way you expect on most platforms these days.)

Неправильный. Это либо неопределенное поведение, если оно вызывает переполнение, либо значение сохраняется.

Анонимный

The value of i is converted to unsigned int ...

Неправильный. Зависит от точности int относительно беззнакового int.

Тейлор Прайс

As was previously answered, you can cast back and forth between signed and unsigned without a problem.

Неправильный. Попытка сохранить значение вне диапазона целого числа со знаком приводит к неопределенному поведению.

Теперь я наконец могу ответить на вопрос.

Если точность int будет равна unsigned int, u будет повышен до подписанного int, и вы получите значение -4444 из выражения (u + i). Теперь, если у нас и у меня есть другие значения, вы можете получить поведение переполнения и неопределенности, но с этими точными числами вы получите -4444 [1]. Это значение будет иметь тип int. Но вы пытаетесь сохранить это значение в беззнаковом int, чтобы затем оно было преобразовано в беззнаковое int, а значение, которое в итоге будет иметь, будет (UINT_MAX + 1) - 4444.

Если точность unsigned int будет больше, чем int, подписанное int будет преобразовано в unsigned int, что даст значение (UINT_MAX + 1) - 5678, которое будет добавлено к другому unsigned int 1234. Если u и я имеют другие значения, из-за которых выражение выходит за пределы диапазона {0..UINT_MAX}, значение (UINT_MAX + 1) будет либо добавляться, либо вычитаться до тех пор, пока результат НЕ попадет в диапазон {0..UINT_MAX), и не произойдет неопределенное поведение .

Что такое точность?

Целые числа имеют биты заполнения, биты знака и биты значения. Беззнаковые целые числа, очевидно, не имеют знакового бита. Кроме того, гарантируется, что беззнаковый символ не имеет битов заполнения. Число битов значений целого числа определяет степень его точности.

[Попался]

Один только макрос sizeof не может использоваться для определения точности целого числа, если присутствуют биты заполнения. И размер байта не обязательно должен быть октетом (восемь бит), как определено C99.

[1] Переполнение может произойти в одной из двух точек. Либо перед добавлением (во время продвижения) - когда у вас есть неподписанное int, которое слишком велико, чтобы поместиться внутри int. Переполнение может также произойти после добавления, даже если беззнаковое int находилось в пределах диапазона int, после добавления результат может все еще переполниться.

What implicit conversions are going on here,

i будет преобразовано в целое число без знака.

and is this code safe for all values of u and i?

Безопасный в смысле четкого определения да (см. https://stackoverflow.com/a/50632/5083516).

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

Сложение, вычитание и умножение будут корректно работать с этими числами, что приведет к получению другого целого числа без знака, содержащего двоичное дополнение, представляющее «реальный результат».

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

(Safe, in the sense that even though result in this example will overflow to some huge positive number, I could cast it back to an int and get the real result.)

В то время как преобразования из подписанного в беззнаковый определяются стандартом, обратное определяется реализацией, и gcc, и msvc определяют преобразование таким образом, что вы получите «реальный результат» при преобразовании числа с дополнением до 2, хранящегося в целочисленном без знака, обратно в целое число со знаком. . Я ожидаю, что вы обнаружите любое другое поведение только в малоизвестных системах, которые не используют дополнение 2 для целых чисел со знаком.

https://gcc.gnu.org/onlinedocs/gcc/Integers-implementation.html#Integers-implementationhttps://msdn.microsoft.com/en-us/library/0eex498h.aspx