Может ли unsigned long intсодержать десятизначное число (1 000 000 000 - 9 999 999 999) на 32-битном компьютере?
Кроме того, каковы диапазоны unsigned long int, long int, unsigned int, short int, short unsigned int, и int?
Ответы:
В минимальных диапазонах вы можете положиться на это:
short intи int: от -32 767 до 32 767unsigned short intи unsigned int: от 0 до 65 535long int: От -2 147 483 647 до 2 147 483 647unsigned long int: От 0 до 4 294 967 295Это означает, что нет, long int нельзя полагаться на сохранение любого 10-значного числа. Однако более крупный тип long long intбыл представлен в C в C99 и C ++ в C ++ 11 (этот тип также часто поддерживается в качестве расширения компиляторами, созданными для более старых стандартов, которые его не включали). Минимальный диапазон для этого типа, если ваш компилятор поддерживает его:
long long int: -9,223,372,036,854,775,807 до 9,223,372,036,854,775,807unsigned long long int: 0 до 18 446 744 073 709 551 615Так что этот тип будет достаточно большим (опять же, если он у вас есть).
Примечание для тех, кто считает, что я ошибся с этими нижними границами - я этого не сделал. Требования C для диапазонов написаны так, чтобы допускать целочисленные представления с дополнением единиц или знаковой величиной, где наименьшее представимое значение и наибольшее представимое значение отличаются только знаком. Также разрешено иметь представление с дополнением до двух, где значение с битом знака 1 и всеми битами значения 0 является представлением ловушки, а не допустимым значением. Другими словами, intэто не требуется , чтобы иметь возможность представлять значение 32768.
intзначит long int.
Размер числовых типов не определен в стандарте C ++, хотя минимальные размеры определены. Чтобы узнать, какого они размера на вашей платформе, используйте числовые ограничения.
Например, максимальное значение для int можно найти следующим образом:
std::numeric_limits<int>::max();
Компьютеры не работают с основанием 10, что означает, что максимальное значение будет в форме 2 n -1 из-за того, как числа представлены в памяти. Возьмем, например, восемь бит (1 байт)
0100 1000
Самый правый бит (число), когда установлен в 1, представляет 2 0 , следующий бит 2 1 , затем 2 2 и так далее, пока мы не дойдем до самого левого бита, который, если число без знака, представляет 2 7 .
Таким образом, число представляет 2 6 + 2 3 = 64 + 8 = 72, потому что 4-й бит справа и 7-й бит справа налево установлены.
Если мы установим все значения в 1:
11111111
Число теперь (при условии беззнакового )
128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 = 2 8 - 1
И, как мы видим, это наибольшее возможное значение, которое может быть представлено 8 битами.
На моей машине int и long одинаковы, каждый из них может содержать от -2 31 до 2 31-1 . По моему опыту, это наиболее распространенный размер на современной 32-битной настольной машине.
Чтобы узнать ограничения в вашей системе:
#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 и C ++ 11.
Другие люди здесь будут публиковать ссылки на data_sizes, precision и т. Д.
Я расскажу вам, как это выяснить самостоятельно.
Напишите небольшое приложение, которое будет делать следующее.
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.
Теперь сделайте это для длинных, коротких и любых других значений INTEGER, которые вам интересны.
NB: этот подход не будет работать для чисел с плавающей запятой (т.е. double или float).
Надеюсь это поможет
В C ++ теперь int и другие данные хранятся с использованием метода дополнения 2. Это означает, что диапазон:
-2147483648 to 2147483647
или от -2 ^ 31 до 2 ^ 31-1
1 бит зарезервирован для 0, поэтому положительное значение на единицу меньше 2 ^ (31)
Вы можете использовать numeric_limits<data_type>::min()и numeric_limits<data_type>::max()функцию представление в limitsфайле заголовок и найти пределы каждого типа данных.
#include <iostream>
#include <limits>
using namespace std;
int main()
{
cout<<"Limits of Data types:\n";
cout<<"char\t\t\t: "<<static_cast<int>(numeric_limits<char>::min())<<" to "<<static_cast<int>(numeric_limits<char>::max())<<endl;
cout<<"unsigned char\t\t: "<<static_cast<int>(numeric_limits<unsigned char>::min())<<" to "<<static_cast<int>(numeric_limits<unsigned char>::max())<<endl;
cout<<"short\t\t\t: "<<numeric_limits<short>::min()<<" to "<<numeric_limits<short>::max()<<endl;
cout<<"unsigned short\t\t: "<<numeric_limits<unsigned short>::min()<<" to "<<numeric_limits<unsigned short>::max()<<endl;
cout<<"int\t\t\t: "<<numeric_limits<int>::min()<<" to "<<numeric_limits<int>::max()<<endl;
cout<<"unsigned int\t\t: "<<numeric_limits<unsigned int>::min()<<" to "<<numeric_limits<unsigned int>::max()<<endl;
cout<<"long\t\t\t: "<<numeric_limits<long>::min()<<" to "<<numeric_limits<long>::max()<<endl;
cout<<"unsigned long\t\t: "<<numeric_limits<unsigned long>::min()<<" to "<<numeric_limits<unsigned long>::max()<<endl;
cout<<"long long\t\t: "<<numeric_limits<long long>::min()<<" to "<<numeric_limits<long long>::max()<<endl;
cout<<"unsiged long long\t: "<<numeric_limits<unsigned long long>::min()<<" to "<<numeric_limits<unsigned long long>::max()<<endl;
cout<<"float\t\t\t: "<<numeric_limits<float>::min()<<" to "<<numeric_limits<float>::max()<<endl;
cout<<"double\t\t\t: "<<numeric_limits<double>::min()<<" to "<<numeric_limits<double>::max()<<endl;
cout<<"long double\t\t: "<<numeric_limits<long double>::min()<<" to "<<numeric_limits<long double>::max()<<endl;
}
Результатом будет: Пределы типов данных:
Для беззнакового типа данных знаковый бит отсутствует, и все биты предназначены для данных; тогда как для типа данных со знаком MSB указывается знаковый бит, а остальные биты предназначены для данных.
Чтобы найти диапазон, выполните следующие действия:
Шаг: 1 -> Узнать количество байтов для данного типа данных.
Шаг: 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
Например,
Для беззнакового int size = 4 байта (32 бита) -> Диапазон [0, (2 ^ (32)) - 1]
Для подписанного int size = 4 байта (32 бита) -> Диапазон [- (2 ^ (32-1)), (2 ^ (32-1)) - 1]
Нет, только часть десятизначного числа может быть сохранена в длинном int без знака, допустимый диапазон которого составляет от 0 до 4 294 967 295. вы можете обратиться к этому: http://msdn.microsoft.com/en-us/library/s3f49ktz(VS.80).aspx
Вы должны посмотреть на специализации шаблона numeric_limits <> для данного типа. Его в шапке.