Какой диапазон значений может хранить целые типы в С++

Ответ 1

Минимальными диапазонами, на которые вы можете положиться, являются:

• short int и int: -32,767 до 32,767
• unsigned short int и unsigned int: от 0 до 65535
• long int: -2,147,483,647 до 2,147,483,647
• unsigned long int: от 0 до 4 294 967 295

Это означает, что no, long int не может полагаться на сохранение 10-значного числа. Однако более крупный тип long long int был введен для C в C99 и С++ в С++ 11 (этот тип также часто поддерживается как расширение компиляторами, созданными для более старых стандартов, которые его не включают). Минимальный диапазон для этого типа, если ваш компилятор поддерживает его, составляет:

• long long int: -9,223,372,036,854,775,807 до 9,223,372,036,854,775,807
• unsigned long long int: от 0 до 18 446 744 073 709 551 615

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

Заметка для тех, кто считает, что я допустил ошибку с этими нижними границами - я этого не сделал. Требования C для диапазонов записываются так, чтобы их можно было комбинировать с целыми числами или знаками, где наименьшее представимое значение и наивысшее представляемое значение отличаются только знаком. Также разрешено иметь представление с двумя дополнениями, где значение со знаком-битом 1 и всеми битами значения 0 является представлением ловушки, а не юридическим значением. Другими словами, int не требуется для представления значения -32,768.

Ответ 2

Размер числовых типов не определен в стандарте С++, хотя минимальные размеры. Способ узнать, какой размер они находятся на вашей платформе, заключается в использовании числовых ограничений

Например, максимальное значение для int может быть найдено:

std::numeric_limits<int>::max();

Компьютеры не работают в базе 10, а это означает, что максимальное значение будет иметь вид 2 ⁿ -1 из-за того, как цифры представляют в памяти. Возьмем, например, восемь бит (1 байт)

  0100 1000

Самый правый бит (число), когда он установлен в 1, представляет 2 ⁰ следующий бит 2 ¹ затем 2 ² и так до тех пор, пока мы не дойдем до самого левого бита, который, если число без знака, представляет 2 ⁷.

Итак, число представляет 2 ⁶ + 2 ³= 64 + 8 = 72, потому что установлены 4-й бит справа и 7-й бит вправо слева.

Если мы установим все значения в 1:

11111111

Теперь число (предполагается без знака)
128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 = 2 ⁸ - 1
И, как мы видим, это самое большое возможное значение, которое может быть представлено 8 битами.

На моей машине и int и длинные одинаковы, каждый из них может удерживать между -2 ³¹ до 2 ³¹ - 1. По моему опыту наиболее распространенный размер на современном 32-битном настольном компьютере.

Ответ 3

Другие люди здесь будут размещать ссылки на data_sizes и precisions и т.д.
Я расскажу вам, как это понять.
Напишите небольшое приложение, которое будет делать следующее.

unsigned int ui;
std::cout <<  sizeof(ui));

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

Предположим, что это 4.

Теперь вы хотите сохранить максимальное значение 4 байта, максимальное значение для одного байта (в шестнадцатеричном формате) 0xFF. Максимальное значение четырех байтов - 0x, за которым следует 8 f (одна пара f для каждого байта, 0x сообщает компилятору, что следующая строка - это шестнадцатеричный номер). Теперь измените свою программу, чтобы присвоить это значение и распечатать результат

unsigned int ui = 0xFFFFFFFF;
std::cout <<  ui;

Это максимальное значение, которое может содержать unsigned int, показанное в представлении базы 10.

Теперь сделайте это для long's, shorts и любого другого значения INTEGER, которое вам интересно.

NB: этот подход не будет работать для чисел с плавающей запятой (т.е. double или float).

Надеюсь, что это поможет

Ответ 4

Чтобы узнать пределы вашей системы:

#include <iostream>
#include <limits>
int main(int, char **) {
  std::cout
    << static_cast< int >(std::numeric_limits< char >::max()) << "\n"
    << static_cast< int >(std::numeric_limits< unsigned char >::max()) << "\n"
    << std::numeric_limits< short >::max() << "\n"
    << std::numeric_limits< unsigned short >::max() << "\n"
    << std::numeric_limits< int >::max() << "\n"
    << std::numeric_limits< unsigned int >::max() << "\n"
    << std::numeric_limits< long >::max() << "\n"
    << std::numeric_limits< unsigned long >::max() << "\n"
    << std::numeric_limits< long long >::max() << "\n"
    << std::numeric_limits< unsigned long long >::max() << "\n";
}

Обратите внимание, что long long является только законным в C99 и С++ 11.

Ответ 5

В С++ теперь int и другие данные сохраняются с использованием метода 2 комплиментов. Это означает, что диапазон:

-2147483648 to 2147483647

или -2 ^ 31 до 2 ^ 31-1

1 бит зарезервирован для 0, поэтому положительное значение равно меньше 2 ^ (31)

Ответ 6

Для неподписанных типов данных нет знакового бита, и все биты для данных ; тогда как для подписанного типа данных MSB указывается знаковый бит, а остальные бит - для данных.

Чтобы найти диапазон, выполните следующие действия:

Шаг: 1 → Вывести no из байтов для типа данных предоставления.

Шаг: 2 → Применить следующие вычисления.

      Let n = no of bits in data type  

      For signed data type ::
            Lower Range = -(2^(n-1)) 
            Upper Range = (2^(n-1)) - 1)  

      For unsigned data type ::
            Lower Range = 0 
            Upper Range = (2^(n)) - 1 

Например,

Для unsigned int size = 4 байта (32 бит) → Диапазон [0, (2 ^ (32)) - 1]

Для подписанного int size = 4 байта (32 бит) → Диапазон [- (2 ^ (32-1)), (2 ^ (32-1)) - 1]

Ответ 7

Нет, только часть десятизначного числа может быть сохранена в unsigned long int, действительный диапазон которого составляет от 0 до 4 294 967 295. вы можете обратиться к этому: http://msdn.microsoft.com/en-us/library/s3f49ktz(VS.80).aspx

Ответ 8

Может ли unsigned long int удерживать десятизначный номер (1,000,000,000 - 9,999,999,999) на 32-разрядном компьютере.

Нет

Ответ 9

Вы должны посмотреть на специализации шаблона numeric_limits < > для данного типа. Его в заголовке.