В настоящее время я исправляю устаревшую ошибку в коде C. В процессе исправления этой ошибки я сохранил unsigned int в unsigned long long. Но, к моему удивлению, математика перестала работать, когда я скомпилировал этот код в 64-битной версии GCC. Я обнаружил, что проблема в том, что когда я назначил значение long long int, тогда я получил число, которое выглядело как 0x0000000012345678, но на 64-битной машине это число стало 0xFFFFFFFF12345678.
Может кто-нибудь объяснить мне или указать мне какую-то спецификацию или документацию о том, что должно произойти при хранении меньшего типа данных в более крупном, и, возможно, какой подходящий шаблон для этого делается на C?
Обновление - пример кода
Вот что я делаю:
// Results in 0xFFFFFFFFC0000000 in 64 bit gcc 4.1.2
// Results in 0x00000000C0000000 in 32 bit gcc 3.4.6
u_long foo = 3 * 1024 * 1024 * 1024;
Я думаю, вы должны сказать компилятору, что число справа не указано. В противном случае он думает, что это нормальный подписанный int, и поскольку бит знака установлен, он считает его отрицательным, а затем он подписывает - расширяет его в приемник.
Итак, сделайте некоторое беззнаковое кастинг справа.
Выражения, как правило, оцениваются независимо; на их результаты не влияет контекст, в котором они появляются.
Целочисленная константа, такая как 1024, имеет наименьшую из int, long int, long long int, в которую будет вписываться ее значение; в частном случае 1024, что всегда int.
Я предполагаю, что u_long является typedef для unsigned long (хотя вы также упоминали long long в своем вопросе).
Итак, дано:
unsigned long foo = 3 * 1024 * 1024 * 1024;
4 константы в выражении инициализации все типа int, и все три умножения int -by- int. Результат оказывается больше (в 1,5 раза), чем 2 31 что означает, что он не будет вписываться в int в систему, где int - 32 бита. Результат int, независимо от того, что он есть, будет неявно преобразован в целевой тип unsigned long, но к этому времени он слишком поздно; переполнение уже произошло.
Переполнение означает, что ваш код имеет поведение undefined (и поскольку это можно определить во время компиляции, я бы ожидал, что ваш компилятор предупредит об этом). На практике подписанное переполнение обычно обертывается, поэтому указанное выше правило обычно устанавливает foo в -1073741824. Вы не можете рассчитывать на это (и это не то, что вы хотите в любом случае).
Идеальное решение заключается в том, чтобы избежать неявных преобразований, гарантируя, что все имеет целевой тип в первую очередь:
unsigned long foo = 3UL * 1024UL * 1024UL * 1024UL;
(Строго говоря, только первый операнд должен иметь тип unsigned long, но проще быть последовательным.)
Посмотрим на более общий случай:
int a, b, c, d; /* assume these are initialized */
unsigned long foo = a * b * c * d;
Вы не можете добавить суффикс UL к переменной. Если возможно, вы должны изменить объявления a, b, c и d, так что они имеют тип unsigned long long, но, возможно, есть и другая причина, по которой они должны быть типа int, Вы можете добавить броски, чтобы явно преобразовать каждый из них в правильный тип. Используя трансляции, вы можете точно контролировать, когда выполняются преобразования:
unsigned long foo = (unsigned long)a *
(unsigned long)b *
(unsigned long)d *
(unsigned long)d;
Это становится немного подробным; вы можете рассмотреть применение применения только к самому левому операнду (после того, как вы поймете, как выражение анализируется).
ПРИМЕЧАНИЕ. Это не будет работать:
unsigned long foo = (unsigned long)(a * b * c * d);
Листинг преобразует результат int в unsigned long, но только после того, как переполнение уже произошло. Он просто указывает явно листинг, который был бы выполнен неявно.
Интегральные литералы с суффиксом являются int, если они могут поместиться, в вашем случае 3 и 1024 могут определенно соответствовать. Это описано в стандартном разделе проекта C99 6.4.4.1 Целочисленные константы, цитата этого раздела может быть найдена в моем ответе на Являются ли макросы C неявным образом?. p >
Далее у нас есть умножение, которое выполняет обычные преобразования арифметических преобразований на его операндах, но так как они все int, результат которых слишком велик, чтобы соответствовать подписанному int, что приводит к переполнению. Это поведение undefined в соответствии с разделом 5, в котором говорится:
Если при оценке выражения возникает исключительное условие (т.е. если результат не определяется математически или нет в диапазоне представимых значений для его тип), поведение undefined.
Мы можем обнаружить это поведение undefined эмпирически, используя флаги clang и -fsanitize=undefined (увидеть его вживую), в котором говорится:
Ошибка выполнения: целочисленное переполнение цепочки: 3145728 * 1024 не может быть представлено в типе 'int'
Хотя в двух дополнениях это будет просто отрицательным числом. Один из способов исправить это - использовать суффикс ul:
3ul * 1024ul * 1024ul * 1024ul
Итак, почему отрицательное число, преобразованное в значение без знака, дает очень большое значение без знака? Это описано в разделе 6.3.1.3 Целочисленные и беззнаковые целые числа, которые гласят:
В противном случае, если новый тип без знака, значение преобразуется путем многократного добавления или вычитая одно больше максимального значения, которое может быть представлено в новом типе пока значение не окажется в диапазоне нового типа .49)
который в основном означает unsigned long max + 1 добавляется к отрицательному числу, что приводит к очень большому значению без знака.