Чем отличаются типы данных int и unsigned int
Реальная разница между «int» и » unsigned int»
unsigned int :
32-разрядные данные int без знака типа могут содержать целочисленные значения в диапазоне от 0 до 4,294,967,295. Вы может также ссылаться на этот тип данных просто как unsigned.
никакой разницы, О. О. Я немного запутался.
9 ответов
хехе. У вас есть неявный бросок здесь, потому что вы говорите printf какой тип ожидать.
попробуйте это вместо этого:
Да, потому что в вашем случае они использовать такое же представление.
как указывают R и pmg, технически это неопределенное поведение для передачи аргументы, не соответствующие спецификаторам формата. Таким образом, программа могла делать все (от печати случайных значений до сбоя, до печати «правильной» вещи и т. д.).
стандарт указывает на это в 7.19.6.1-9
если спецификация преобразования является недопустимым, поведение неопределено. если любой аргумент не является правильным типом для соответствующего преобразования спецификация, поведение не определено.
нет никакой разницы между ними в том, как они хранятся в памяти и регистрах, нет подписанной и неподписанной версии регистров int нет подписанной информации, хранящейся в int, разница становится актуальной только при выполнении математических операций, есть подписанная и неподписанная версия математических операций, встроенных в процессор, и signedness сообщает компилятору, какую версию использовать.
проблема в том, что вы вызвали Неопределено Поведение.
при вызове УБ все может случиться.
назначения в порядке; есть неявное преобразование в первой строке
не УБ!
внутреннее представление int и unsigned int то же самое.
поэтому, когда вы передаете ту же строку формата в printf он будет напечатан как то же самое.
однако, есть различия, когда вы сравниваете их. Подумайте:
Это также может быть оговоркой, потому что при сравнении целого числа со знаком и без знака один из них будет неявно приведен в соответствие с типами.
тип просто говорит вам, что должен представлять битовый шаблон. кусочки-это только то, что вы из них делаете. одни и те же последовательности можно интерпретировать по-разному.
на printf функции интерпретирует значение, которое вы передаете в соответствии со спецификатором формата в соответствующей позиции. Если ты скажешь printf Что вы передаете int и unsigned вместо printf повторно интерпретировать один в другой, и печатать результаты, которые вы видите.
Объясните разницу между int и unsigned int
Вот не понимаю я. Вот к примеру, если я пытаюсь в инт запихать дробное значение, например
1. Прочитай, как положительные и отрицательные числа записываются в двоичной системе.
2. Запиши все приведённые числа в двоичной системе.
3. Проведи над ними все описанные в посте операции. Не забывая про разрядность (т.е. отбрасывая все старшие разряды, которые не укладываются в размер типа).
4. Переведи полученное обратно в десятичную систему. Примерно на этом этапе ты уже должен будешь всё понять.
Правда это в теории, на практике компилятор в данном случае оптимизирует код и делает во время компиляции расчёты в более широких типах данных, дабы не было переполнений
В целом действительно стоит почитать про хранение чисел на цифровых вычислительных устройствах, например по школьному учебнику информатики(8-9 класс) или по Харрисам
Объясните разницу между int и unsigned int
Приводя отрицательное число к беззнаковому ты получаешь число близкое к максимальному, потом ты прибавляешь к нему ещё, тем самым переполняя его, где в итоге 25 и является результатом переполнения.
каким образом по итогу выходит 25
Но при сложении со знаковым типом, а именно он выберется как приоритетный, a будет приведено к знаковому.
Нет же. Если битность одинаковая, то знаковое приводится к беззнаковому, а не беззнаковое к знаковому.
Встроенные типы (C++)
Встроенные типы (также называемые фундаментальными типами) задаются стандартом языка C++ и встроены в компилятор. Встроенные типы не определены в файле заголовка. Встроенные типы делятся на три основные категории: целые, с плавающей запятойи void. Целочисленные типы представляют целые числа. Типы с плавающей запятой могут указывать значения, которые могут содержать дробные части. Большинство встроенных типов рассматриваются компилятором как отдельные типы. Однако некоторые типы являются синонимамиили обрабатываются компилятором как эквивалентные типы.
Тип void
в операторе выражения (Дополнительные сведения см. в разделе выражения.)
в левом операнде оператора запятой (Дополнительные сведения см. в разделе оператор-запятая.)
std:: nullptr_t
Тип Boolean
Символьные типы
Зависящие от Майкрософт: переменные типа помещаются в int тип по signed char умолчанию, если не /J используется параметр компиляции. В этом случае они рассматриваются как тип unsigned char и переносятся в int без расширения знака.
Переменная типа wchar_t является расширенным символом или типом многобайтового символа. Используйте L префикс перед символьным или строковым литералом, чтобы указать тип расширенных символов.
char16_t Тип используется для символьного представления UTF-16. Он должен быть достаточно большим, чтобы представлять любой блок кода UTF-16. Компилятор обрабатывает его как отдельный тип.
char32_t Тип используется для символьного представления UTF-32. Он должен быть достаточно большим, чтобы представлять любую единицу кода UTF-32. Компилятор обрабатывает его как отдельный тип.
Типы с плавающей запятой
Типы с плавающей запятой используют представление IEEE-754, чтобы обеспечить приближение дробных значений к широкому диапазону величин. В следующей таблице перечислены типы с плавающей запятой в C++ и сравнительные ограничения размеров типов с плавающей запятой. Эти ограничения задаются стандартом C++ и не зависят от реализации Майкрософт. Абсолютный размер встроенных типов с плавающей запятой не указан в стандарте.
Конкретно для Майкрософт: представление и double идентично. Однако long double double компилятор обрабатывает как отдельные типы. Компилятор Microsoft C++ использует 4-и 8-байтовые представления с плавающей запятой в формате IEEE-754. Дополнительные сведения см. в разделе IEEE с плавающей точкой.
Целочисленные типы
int Тип является базовым целочисленным типом по умолчанию. Он может представлять все целые числа в диапазоне, зависящем от реализации.
Представление целого числа со знаком — это одно из значений, которое может содержать положительные и отрицательные значения. Он используется по умолчанию или при signed наличии ключевого слова модификатор. unsigned Ключевое слово модификатор задает unsigned представление, которое может содержать только неотрицательные значения.
Реализация должна поддерживать как минимальные требования к размеру, так и отношение размера для каждого типа. Однако фактические размеры могут и зависеть от реализации. См. раздел размеры встроенных типов для деталей реализации, связанных с Майкрософт.
int Ключевое слово можно опустить, если signed unsigned заданы модификаторы, или. Модификаторы и int тип, если они есть, могут использоваться в любом порядке. Например, short unsigned и unsigned int short следует ссылаться на один и тот же тип.
Синонимы целочисленного типа
Компилятор считает синонимами следующие группы типов:
Размеры встроенных типов
Большинство встроенных типов имеют размеры, определенные реализацией. В следующей таблице перечислены объемы хранилища, необходимые для встроенных типов в Microsoft C++. В частности, long имеет 4 байта даже в 64-разрядных операционных системах.
Дополнительные сведения о преобразовании типов см. в разделе стандартные преобразования.
The real difference between «int» and «unsigned int»
The 32-bit int data type can hold integer values in the range of −2,147,483,648 to 2,147,483,647. You may also refer to this data type as signed int or signed.
unsigned int :
The 32-bit unsigned int data type can hold integer values in the range of 0 to 4,294,967,295. You may also refer to this data type simply as unsigned.
Ok, but, in practice:
no difference, O.o. I’m a bit confused.
9 Answers 9
Hehe. You have an implicit cast here, because you’re telling printf what type to expect.
Try this on for size instead:
Yes, because in your case they use the same representation.
As R and pmg point out, technically it’s undefined behavior to pass arguments that don’t match the format specifiers. So the program could do anything (from printing random values to crashing, to printing the «right» thing, etc).
The standard points it out in 7.19.6.1-9
If a conversion specification is invalid, the behavior is undefined. If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined.
There is no difference between the two in how they are stored in memory and registers, there is no signed and unsigned version of int registers there is no signed info stored with the int, the difference only becomes relevant when you perform maths operations, there are signed and unsigned version of the maths ops built into the CPU and the signedness tell the compiler which version to use.
The problem is that you invoked Undefined Behaviour.
When you invoke UB anything can happen.
The assignments are ok; there is an implicit conversion in the first line
Don’t do UB!
The internal representation of int and unsigned int is the same.
Therefore, when you pass the same format string to printf it will be printed as the same.
However, there are differences when you compare them. Consider:
This can be also a caveat, because when comparing signed and unsigned integer one of them will be implicitly casted to match the types.
the type just tells you what the bit pattern is supposed to represent. the bits are only what you make of them. the same sequences can be interpreted in different ways.
The binary representation is the key. An Example: Unsigned int in HEX
Which represents 4,294,967,295 in a base-ten positive number. But we also need a way to represent negative numbers. So the brains decided on twos complement. In short, they took the leftmost bit and decided that when it is a 1 (followed by at least one other bit set to one) the number will be negative. And the leftmost bit is set to 0 the number is positive. Now let’s look at what happens
Adding to the number we finally reach.
the highest positive number with a signed integer. Let’s add 1 more bit (binary addition carries the overflow to the left, in this case, all bits are set to one, so we land on the leftmost bit)
So I guess in short we could say the difference is the one allows for negative numbers the other does not. Because of the sign bit or leftmost bit or most significant bit.
C / C ++ использование int или unsigned int
Во многих примерах кода, исходном коде, библиотеках и т. Д. Я вижу использование int, когда, насколько я вижу, unsigned int будет иметь гораздо больше смысла.
Одно место, где я вижу это, находится в for петли. Смотрите ниже пример:
Решение
С помощью unsigned может вводить программные ошибки, которые трудно обнаружить, и обычно лучше использовать подписанные int просто чтобы избежать их. Одним из примеров может быть ситуация, когда вы решаете выполнять итерацию назад, а не вперед, и писать это:
Другой будет, если вы будете делать математику внутри цикла:
С помощью unsigned представляет потенциальные ошибки такого рода, и в действительности нет никаких преимуществ.
Другие решения
Это вообще лень или непонимание.
Я всегда использую unsigned int, когда значение не должно быть отрицательным. Это также служит целям документации определения правильных значений.
ИМХО, утверждение, что безопаснее использовать «int», чем «unsigned int», просто неверно и является плохой практикой программирования.
Если вы использовали Ada или Pascal, вы бы привыкли использовать еще более безопасную практику указания конкретных диапазонов значений (например, целое число, которое может быть только 1, 2, 3, 4, 5).
Вы могли бы продолжить, почему length быть подписанным? Ну, это, вероятно, исторический.
Кроме того, если вы решили изменить цикл, т.е.
логика ломается, если вы используете беззнаковые целые.
Я решил быть максимально явным при программировании. То есть, если я собираюсь использовать переменную, значение которой всегда положительно, то unsigned используется. Многие здесь упоминают «трудно обнаружить ошибки», но немногие приводят примеры. Рассмотрим следующий пример использования unsigned в отличие от большинства постов здесь:
Во втором случае вы фактически поймаете это во время выполнения, потому что подпись thing_ID заставляет условное выполнить без знака сравнения.
Я использую unsigned int только тогда, когда длина больше значения max int. Использование unsigned int может привести к трудно обнаруживаемым ошибкам, особенно если длина переменная.
этот крошечный код связан с прецедентом, если вы вызываете какой-то векторный элемент, тогда прототип является int, но есть много современных способов сделать это на C ++, например. для (const auto &v: vec) <> или итераторы, в некоторых вычислениях, если нет вычитания / достижения отрицательного числа, вы можете и должны использовать unsigned (лучше объясняет диапазон ожидаемых значений), иногда, так как многие опубликованные примеры показывают, что вам действительно нужен int, но правда в том, что все дело в прецеденте и ситуации, ни одно строгое правило не применимо ко всем случаям использования, и было бы глупо заставить его перебить …