Я правильно говорю, что разница между целым числом, подписанным и без знака, равна:
Любые другие отличия?
Без знака может иметь большее положительное значение, а не отрицательное значение.
Да.
Неподписанный использует начальный бит как часть значения, в то время как подписанная версия использует самый левый бит, чтобы определить, является ли число положительным или отрицательным.
Существуют разные способы представления целых чисел со знаком. Самым простым для визуализации является использование самого левого бита в качестве флага (знак и величина), но более распространенным является два дополнения. Оба используются в большинстве современных микропроцессоров - с плавающей запятой используются знак и величина, а целочисленная арифметика использует два дополнения.
целые числа со знаком могут содержать как положительные, так и отрицательные числа.
да
Я пойду на различия на аппаратном уровне, на x86. Это в основном не имеет значения, если вы не пишете компилятор или не используете язык ассемблера. Но это приятно знать.
Во-первых, x86 имеет встроенную поддержку двух дополнений для представления подписанных чисел. Вы можете использовать другие представления, но для этого потребуется больше инструкций и, как правило, будет пустой тратой времени процессора.
Что я подразумеваю под "родной поддержкой"? В основном я имею в виду, что есть набор инструкций, которые вы используете для чисел без знака и другого набора, который вы используете для подписанных чисел. Беззнаковые числа могут находиться в тех же регистрах, что и подписанные числа, и вы можете смешивать подписанные и неподписанные инструкции, не беспокоясь о процессоре. Это до компилятора (или программиста сборки), чтобы отслеживать, подписано ли число или нет, и используйте соответствующие инструкции.
Во-первых, два номера дополнений обладают тем свойством, что сложение и вычитание являются такими же, как для неподписанных чисел. Не имеет значения, являются ли цифры положительными или отрицательными. (Таким образом, вы просто продолжаете и ADD и SUB свои номера, не беспокоясь.)
Различия начинают показывать, когда дело доходит до сравнений. x86 имеет простой способ их дифференцирования: выше/ниже указывает сравнение без знака и больше/меньше, чем указывает сопоставленное сравнение. (Например, JAE означает "Перейти, если выше или равно" и не имеет знака.)
Существует также два набора инструкций умножения и деления для работы с подписанными и беззнаковыми целыми числами.
Наконец: если вы хотите проверить, скажем, переполнение, вы сделали бы это по-другому для подписанных и для чисел без знака.
Он только спросил о подписанных и неподписанных. Не знаю, почему люди добавляют дополнительные вещи в это. Позвольте мне сказать вам ответ.
Без знака: он состоит только из неотрицательных значений, то есть от 0 до 255.
Подпись: состоит из отрицательных и положительных значений, но в разных форматах, таких как
И это объяснение о 8-битной системе счисления.
Всего лишь несколько баллов за полноту:
В этом ответе обсуждаются только целые представления. Могут быть другие ответы для плавающей запятой;
представление отрицательного числа может меняться. Наиболее распространенным сегодня (сегодня - сегодня почти универсальным) сегодня является два дополнения. Другие представления включают одно дополнение (довольно редко) и подписанная величина (исчезающе редко встречающаяся, вероятно, только на музейных произведениях), которая просто использует высокий бит в качестве индикатора с остаются биты, представляющие абсолютное значение числа.
При использовании двух дополнений переменная может представлять больший диапазон (на единицу) отрицательных чисел, чем положительные числа. Это связано с тем, что нуль включен в "положительные" числа (поскольку знаковый бит не установлен для нуля), но не отрицательные числа. Это означает, что абсолютное значение наименьшего отрицательного числа не может быть представлено.
при использовании одного дополнения или знаковой величины вы можете иметь нуль, представленный как положительное или отрицательное число (что является одной из нескольких причин, по которым эти представления обычно не используются).
В соответствии с тем, что мы узнали в классе, целые числа со знаком могут представлять как положительные, так и отрицательные числа, а целые числа без знака - только неотрицательные.
Например, глядя на 8-разрядный номер:
неподписанные значения 0 - 255
значенные значения варьируются от -128 до 127
Все, кроме пункта 2, является правильным. Существует много разных обозначений для подписанных ints, некоторые реализации используют первый, другие используют последний, а другие используют нечто совершенно другое. Все зависит от платформы, с которой вы работаете.
Другое отличие заключается в том, что вы конвертируете целые числа разных размеров.
Например, если вы извлекаете целое число из байтового потока (например, 16 бит для простоты), с неподписанными значениями вы можете сделать:
i = ((int) b[j]) << 8 | b[j+1]
(должен, вероятно, записать 2 nd байт, но я предполагаю, что компилятор пойдет правильно)
С подписанными значениями вам придется беспокоиться о расширении знака и делать:
i = (((int) b[i]) & 0xFF) << 8 | ((int) b[i+1]) & 0xFF
Вообще говоря, это правильно. Не зная ничего больше о том, почему вы ищете различия, я не могу думать о каких-либо других отличиях между подписанными и неподписанными.
(в ответ на второй вопрос). Используя только битовый знак (а не 2 дополнение), вы можете получить -0. Не очень красиво.
Помимо того, что другие сказали в C, вы не можете переполнять целое число без знака; поведение определяется как арифметика модуля. Вы можете переполнить целое число со знаком и, теоретически (хотя и не на практике в текущих системах основного), переполнение может вызвать ошибку (возможно, похоже на деление на нулевую ошибку).
Целые числа без знака гораздо чаще поймают вас в определенной ловушке, чем целые числа со знаком. Ловушка исходит из того, что в то время как 1 и 3 выше правильные, обеим типам целых чисел может быть присвоено значение за пределами того, что он может "удерживать", и он будет преобразован молча.
unsigned int ui = -1;
signed int si = -1;
if (ui < 0) {
printf("unsigned < 0\n");
}
if (si < 0) {
printf("signed < 0\n");
}
if (ui == si) {
printf("%d == %d\n", ui, si);
printf("%ud == %ud\n", ui, si);
}
Когда вы запустите это, вы получите следующий вывод, даже если оба значения были присвоены -1 и объявлены по-разному.
signed < 0
-1 == -1
4294967295d == 4294967295d
Подписанные целые числа в C представляют числа. Если a и b являются переменными со знаком целочисленных типов, стандарт никогда не потребует, чтобы компилятор сделал выражение a+=b хранилищем в a чем-либо другим, кроме арифметической суммы их соответствующих значений. Разумеется, если бы арифметическая сумма не уместилась в a, процессор, возможно, не смог бы ее поместить, но стандарт не потребовал бы, чтобы компилятор обрезал или обернул значение или сделал что-нибудь еще в этом случае, если значения, превышающие пределы для их типов. Обратите внимание, что, хотя стандарт не требует этого, реализациям C допускается ловушка арифметических переполнений со значными значениями.
Неподписанные целые числа в C ведут себя как абстрактные алгебраические кольца целых чисел, которые конгруэнтны по модулю некоторой степени из двух, за исключением сценариев, связанных с преобразованиями или операциями с более крупными типами. Преобразование целого числа любого размера в 32-разрядный неподписанный тип даст член, соответствующий вещам, которые соответствуют этому целому модулю 4 294 967 296. Причина, вычитающая 3 из 2, дает 4 294 967 295, состоит в том, что добавление чего-то конгруэнтного к 3 к чему-то, сравнимому с 4 294 967 295, даст что-то совпадающее с 2.
Абстрактные типы алгебраических колец часто бывают полезными; к сожалению, C использует подпись как решающий фактор для того, должен ли тип вести себя как кольцо. Хуже того, значения без знака рассматриваются как числа, а не члены кольца при преобразовании в более крупные типы, а значения без знака меньше int преобразуются в числа, когда на них выполняется любая арифметика. Если v есть uint32_t, что равно 4,294,967,294, то v*=v; должен сделать v=4. К сожалению, если int - 64 бита, то неизвестно, что может сделать v*=v;.
Учитывая стандартный стандарт, я предлагаю использовать неподписанные типы в ситуациях, когда требуется поведение, связанное с алгебраическими кольцами, и подписанные типы, когда нужно представлять числа. К сожалению, C рисовал различия так, как сделал, но они такие, какие они есть.
Единственное гарантированное различие между подписанным и неподписанным значением в C состоит в том, что подписанное значение может быть отрицательным, 0 или положительным, а unsigned может быть только 0 или положительным. Проблема в том, что C не определяет формат типов (поэтому вы не знаете, что ваши целые числа находятся в двух дополнениях). Строго говоря, первые два упомянутых вами момента неверны.
При программировании на встроенных системах вы должны использовать неподписанные целые числа. В циклах, когда нет необходимости в целых числах со знаком, использование целых чисел без знака спасет безопасность, необходимую для проектирования таких систем.