32 Бита максимальное число

Целое, целочисленный тип данных (англ. Integer ), в информатике — один из простейших и самых распространённых типов данных в языках программирования. Служит для представления целых чисел.

Множество чисел этого типа представляет собой конечное подмножество бесконечного множества целых чисел, ограниченное максимальным и минимальным значениями.

В программировании различают беззнаковые целые числа и целые числа со знаком. Знак числа обычно кодируется старшим битом машинного слова. Традиционно, если старший бит равен 1, то число считается отрицательным, только, если оно не определено как беззнаковое.

Количество чисел в машинном изображении множества целых чисел зависит от длины машинного слова, обычно выражаемой в битах. Например, при длине машинного слова 1 байт (8 бит) диапазон представимых целых чисел со знаком от −128 до 127. В беззнаковом формате байтовое представление числа будет от 0 до 255 (2 8 — 1). Если используется 32-разрядное машинное слово, то целое со знаком будет представлять значения от −2 147 483 648 (-2 31 ) до 2 147 483 647 (2 31 −1); всего 1 0000 0000₁₆ (4 294 967 296₁₀) возможных значений.

Ограничение длины машинного слова, обусловленное конкретной аппаратной реализацией того или иного компьютера, не препятствие для обработки ими весьма длинных в битах представлений целых чисел, достигаемое усложнением программных алгоритмов. Естественное ограничение — конечность ёмкости памяти и разумное время на исполнение.

Целые числа и вычисления с целыми числами в современных компьютерах имеют очень важное значение (в подавляющем количестве приложений занимают меньше ресурсов процессора, чем арифметика с плавающей точкой). Вся адресная арифметика и операции с индексами массивов основаны на целочисленных операциях.

Содержание

Представление [ править | править код ]

В памяти типовой компьютерной системы целое число представлено в виде цепочки битов фиксированного (кратного 8) размера. Эта последовательность нулей и единиц — не что иное, как двоичная запись числа, поскольку обычно для представления чисел в современной компьютерной технике используется позиционный двоичный код. Диапазон целых чисел, как правило, определяется количеством байтов в памяти компьютера, отводимых под одну переменную.

Многие языки программирования предлагают выбор между короткими (англ. short ), длинными (англ. long ) и целыми стандартной длины. Длина стандартного целого типа, как правило, совпадает с размером машинного слова на целевой платформе. Для 16-разрядных операционных систем — этот тип (int) составляет 2 байта и совпадает с типом short int (можно использовать как short, опуская слово int), для 32-разрядных операционных систем он будет равен 4 байтам и совпадает с длинным целым long int (можно использовать как long, опуская слово int), и в этом случае будет составлять 4 байта. Короткое целое short int, для 16-разрядных операционных систем, 32-разрядных операционных систем, и для большинства 64-разрядных операционных систем составляет — 2 байта. Также в некоторых языках может использоваться тип данных двойное длинное long long, который составляет 8 байт.

Для 64-разрядных операционных систем, учитывая разность моделей данных (LP64, LLP64, ILP64), представление целого типа на разных моделях данных может отличаться между собой. Тип int и long может составлять как 4, так и 8 байт.

Стоит отметить, что каждый язык программирования реализует свою сигнатуру представления целых чисел, которая может отличаться от международных стандартов, но обязана его/их поддерживать. К примеру можно отнести кросс-платформенную библиотеку Qt, где целое представляется типом qintX и quintX, где X-8,16,32,64.

Целые типы подразделяются на беззнаковые (англ. unsigned ) и знаковые (англ. signed ).

Беззнаковые целые [ править | править код ]

Беззнаковые целые представляют только неотрицательные числа, при этом все разряды кода используются для представления значения числа и максимальное число соответствует единичным значениям кода во всех разрядах: 111…111. m-байтовая переменная целого типа без знака, очевидно, принимает значения от 0 до +2 8m −1.

В C и C++ для обозначения беззнаковых типов используется префикс unsigned . В C# в качестве показателя беззнаковости используется префикс u (англ. unsigned). Например, для объявления беззнакового целого, равного по размеру одному машинному слову используется тип uint .

Беззнаковые целые, в частности, используются для адресации памяти, представления символов.

Иногда в литературе [1] встречаются рекомендации не использовать тип беззнаковые целые, поскольку он может быть не реализован процессором компьютера, однако вряд ли этот совет следует считать актуальным — большинство современных процессоров (в том числе x86-совместимые [2] ) одинаково хорошо работают как со знаковыми, так и с беззнаковыми целыми.

В некоторых языках, например Java, беззнаковые целые типы (за исключением символьного) отсутствуют [3] .

Неправильное использование беззнаковых целых может приводить к неочевидным ошибкам из-за возникающего переполнения [4] . В приведённом ниже примере использование беззнаковых целых в цикле в C и C++ превращает этот цикл в бесконечный:

Целые со знаком [ править | править код ]

Существует несколько различных способов представления целых значений в двоичном коде в виде величины со знаком (англ.) русск. . В частности можно назвать прямой и обратный коды. Знак кодируется в старшем разряде числа: 0 соответствует положительным, а 1 отрицательным числам.

Могут быть использованы и более экзотические представления отрицательных чисел, такие, как, например, система счисления по основанию −2. [5]

Однако для большинства современных процессоров обычным представлением чисел со знаком является дополнительный код. Максимальное положительное число представляется двоичным кодом 0111…111, максимальное по модулю отрицательное кодом 1000…000, а код 111…111 соответствует −1. Такое представление чисел соответствует наиболее простой реализации арифметических логических устройств процессора на логических вентилях и позволяет использовать один и тот же алгоритм сложения и вычитания как для беззнаковых чисел, так и для чисел со знаком (отличие — только в условиях, при которых считается, что наступило арифметическое переполнение).

m-байтовая переменная целого типа со знаком принимает значения от −2 8m-1 до +2 8m-1 −1.

Предельные значения для разных разрядностей [ править | править код ]

Ниже представлена таблица предельных значений десятичных чисел для разных разрядностей при кодировании дополнительным кодом. В столбце «Максимальное десятичное» сначала идёт максимальное значение целого без знака, а под ним минимальное и максимальное целое со знаком.

Операции над целыми [ править | править код ]

Арифметические операции [ править | править код ]

К целочисленным значениям применимы в первую очередь арифметические операции. Ниже приведены самые часто используемые (в скобках указаны их обозначения в различных языках программирования и им аналогичным средствах).

• Сравнение (англ. comparison ). Здесь применимы соотношения «равно» (« = »; « == »; « eq »), «не равно» (« != »; « <> »; « ne »), «больше» (« > »; « gt »), «больше или равно» (« >= »; « ge »), «меньше» (« »; « lt ») и «меньше или равно» (« »; « le »).
• Инкремент (англ.increment ; « ++ ») и декремент (англ.decrement ; « — ») — арифметическое увеличение или уменьшение числа на единицу. Выделено в отдельные операции из-за частого использования с переменными-счётчиками в программировании.
• Сложение (англ.addition ; « + ») и вычитание (англ.subtraction ; « — »).
• Умножение (англ.multiplication ; « * »).
• Деление (англ.division ; « / »; « ») и получение остатка от деления (англ.modulo ; « % »). Некоторые процессоры (например, архитектуры x86) позволяют производить обе эти операции за одну инструкцию.
• Инверсия знака (англ.negation ) и получение абсолютного значения (англ.absolute ).
• Получение знака. Результатом такой операции обычно является 1 для положительных значений, −1 — для отрицательных и 0 — для нуля.
• Возведение в степень ( «^» ).

В некоторых языках программирования для лаконичности есть операторы, которые позволяют производить арифметическую операцию с присвоением. Например, « += » складывает текущее значение переменной слева с выражением справа и помещает результат в исходную переменную. Так же в некоторых языках и средах доступна совмещённая операция MulDiv, которая умножает на одно число, а потом делит результат на второе.

Обычно самыми дорогими по скорости операциями являются умножение и деление (получение остатка от деления).

В памяти компьютера для хранения целых чисел обычно отводятся ячейки фиксированного объёма. Из-за этого операции увеличения и уменьшения значений могут приводить к переполнению, что оборачивается искажением результата. Некоторые языки программирования позволяют производит вызов исключения в таких случаях. Кроме этого, можно определять поведение при переполнении:

• Циклическая операция (обычно происходит по умолчанию). Например, если сделать инкремент 8-битного беззнакового значения 255, то получится 0.
• Операция с насыщением. Если будет достигнут предел, то конечным значением будет это предельное. Например, если к 8-битному беззнаковому числу 250 прибавить 10, то получится 255. Сложение, вычитание и умножение с насыщением обычно применяется при работе с цветом.

Побитовые операции [ править | править код ]

Помимо математических, к целым числам применимы битовые операции, которые основаны на особенностях позиционного двоичного кодирования. Обычно они выполняются значительно быстрее арифметических операций и поэтому их используют как более оптимальные аналоги.

• Битовый сдвиг влево с дополнением нулями аналогичен умножению числа на степень двойки (количество бит сдвига соответствует степени двойки).
• Битовый сдвиг вправо аналогичен делению на степень двойки (количество бит сдвига соответствует степени двойки). Некоторые языки программирования и процессоры поддерживают арифметический сдвиг, который позволяет сохранять знак у целых со знаком (сохраняется значение старшего бита).
• У целых со знаком знак можно узнать по старшему биту (у отрицательных он установлен).
• Чтение и установка младшего бита позволяет управлять чётностью (у нечётных чисел он установлен).
• Побитовое «И» над определённым количеством младших бит позволяет узнать остаток от деления на степень двойки (степень соответствует количеству бит).
• Побитовое «ИЛИ» над определённым количеством младших бит и последующий инкремент округляет число на значение, равное степени двойки (степень соответствует количеству бит) — используется для выравнивания адресов и размеров на определённое значение.

Работа со строками [ править | править код ]

Довольно частыми операциями являются получение строки из числового значения во внутреннем представлении и обратно — число из строки. При преобразовании в строку обычно доступны средства задания форматирования в зависимости от языка пользователя.

Ниже перечислены некоторые из представлений чисел строкой.

• Десятичное число (англ. decimal ). При получении строки обычно можно задать разделители разрядов, количество знаков (добавляются лидирующие нули, если их меньше) и обязательное указание знака числа.
• Число в системе счисления, которое является степенью двойки. Самые частые: двоичное (binary англ. binary ), восьмеричное (англ. octal ) и шестнадцатеричное (англ. hexadecimal ). При получении строки обычно можно задать разделители групп цифр и минимальное количество цифр (производится дополнение нулями, если их меньше). Так как эти представления чаще всего используются в программировании, то здесь обычно доступны соответствующие опции. Например, указание префикса и постфикса для получения значения в соответствии с синтаксисом языка. Для 16-ричных актуально указание регистра символов, а также обязательное добавление нуля, если первая цифра представлена буквой (чтобы число не определялось как строковый идентификатор).
• Римское число (англ. roman ).
• Словесное представление (в том числе сумма прописью) — число представляется словами на указанном натуральном языке.

Перечислимый тип [ править | править код ]

К целым относится также перечислимый тип. Переменные перечислимого типа принимают конечный заранее заданный набор значений. Размер набора не определяется числом байтов, используемых для представления целочисленных значений переменных такого типа.

Например, в языке Python логический тип является подтипом целого и использует имена False и True, которые при приведении к целому получают значения 0 и 1 соответственно [6] .

Целый тип char занимает в памяти 1 байт (8 бит) и позволяет выразить в двоичной системе счисления 2^8 значений=256. Тип char может содержать как положительные, так и отрицательные значения. Диапазон изменения значений составляет от -128 до 127.

uchar

Целый тип uchar также занимает в памяти 1 байт, как и тип char, но в отличие от него, uchar предназначен только для положительных значений. Минимальное значение равно нулю, максимальное значение равно 255. Первая буква u в названии типа uchar является сокращением слова unsigned (беззнаковый).

short

Целый тип short имеет размер 2 байта(16 бит) и, соответственно, позволяет выразить множество значений равное 2 в степени 16: 2^16=65 536. Так как тип short является знаковым и содержит как положительные, так и отрицательные значения, то диапазон значений находится между -32 768 и 32 767.

ushort

Беззнаковым типом short является тип ushort, который также имеет размер 2 байта. Минимальное значение равно 0, максимальное значение 65 535.

Целый тип int имеет размер 4 байта (32 бита). Минимальное значение -2 147 483 648, максимальное значение 2 147 483 647.

Беззнаковый целый тип uint занимает в памяти 4 байта и позволяет выражать целочисленные значения от 0 до 4 294 967 295.

Целый тип long имеет размер 8 байт (64 бита). Минимальное значение -9 223 372 036 854 775 808, максимальное значение 9 223 372 036 854 775 807.

ulong

Целый тип ulong также занимает 8 байт и позволяет хранить значения от 0 до 18 446 744 073 709 551 615.

char ch= 12 ;
short sh=- 5000 ;
int in= 2445777 ;

Так как беззнаковые целые типы не предназначены для хранения отрицательных значений, то попытка установить отрицательное значение может привести к неожиданным последствиям. Вот такой невинный скрипт приведет к бесконечному циклу:

//— бесконечный цикл
void OnStart ()
<
uchar u_ch;

for ( char ch=-128;ch
<
u_ch=ch;
Print ( "ch = " ,ch, " u_ch = " ,u_ch);
>
>

Правильно будет так:

//— правильный вариант
void OnStart ()
<
uchar u_ch;

for ( char ch=-128;ch
<
u_ch=ch;
Print ( "ch = " ,ch, " u_ch = " ,u_ch);
if (ch==127) break ;
>
>

ch= -128 u_ch= 128
ch= -127 u_ch= 129
ch= -126 u_ch= 130
ch= -125 u_ch= 131
ch= -124 u_ch= 132
ch= -123 u_ch= 133
ch= -122 u_ch= 134
ch= -121 u_ch= 135
ch= -120 u_ch= 136
ch= -119 u_ch= 137
ch= -118 u_ch= 138
ch= -117 u_ch= 139
ch= -116 u_ch= 140
ch= -115 u_ch= 141
ch= -114 u_ch= 142
ch= -113 u_ch= 143
ch= -112 u_ch= 144
ch= -111 u_ch= 145
.

//— отрицательные значения нельзя хранить в беззнаковых типах
uchar u_ch=-120;
ushort u_sh=-5000;
uint u_in=-401280;

Шестнадцатеричные: цифры 0-9, буквы а-f или А-F для значений 10-15; начинаются с 0х или 0Х.

0x0A , 0x12 , 0X12 , 0x2f , 0xA3 , 0Xa3 , 0X7C7

Я никогда не помню номер. Мне нужно правило памяти.

26 ответов

Это 2,147,483,647. Самый легкий способ запомнить его через татуировку.

В Objective-C (iOS и OSX) просто запомните эти макросы:

Запомните: 21 IQ ITEM 47

Его можно декодировать с любой телефонной панели, или вы можете просто записать его на бумаге.

Чтобы вспомнить «21 IQ ITEM 47», я бы сказал: «Hitman: Codename 47 имел 21 миссию, каждая из которых была IQ ITEM».

Или «Я чищу зубы каждый день в 21:47, потому что у меня высокий IQ и я не люблю предметы во рту».

С Groovy на пути:

(Groovy чрезвычайно полезен для справочника в контексте Java.)

Чтобы никогда не забывать максимальное значение любого типа:

Если оно имеет 32 бита, наибольшим возможным значением будут 32 бита с номером 1:

Результат будет 4294967295 в десятичном виде:

Но, как есть также представление отрицательных чисел, разделите 4294967295 на 2 и получите 2147483647.

Следовательно, 32-разрядное целое число может представлять от -2147483647 до 2147483647.

Вы найдете в двоичном формате максимальное значение Int32 1111111111111111111111111111111, но в десяти основаниях вы найдете 2147483647 или 2 ^ 31-1 или Int32.MaxValue

Попробуйте на Python:

В общем, вы могли бы выполнить простую операцию, которая отражает саму природу Int32, заполнить все доступные биты единицами — это то, что вы можете легко сохранить в своей памяти. Он работает в основном одинаково в большинстве языков, но я собираюсь использовать Python для примера:

Для неподписанных Int32, сделайте его 32 вместо 31 1.

Но так как опубликовано еще несколько авантюрных подходов, я начал думать о формулах, просто для удовольствия .

Формула 1 (Числа объединяются, если оператор не указан)

Формула 2

Быстрый контроль Python

Самый простой способ запомнить это посмотреть на std::numeric_limits ::max()

Просто помните, что 2^ (10*x) приблизительно 10^ (3*x) — Вы, вероятно, уже привыкли к этому с килобайтами/кибибайты и т.д. Это:

, Так как интервал использует 31 бит (+

1 бит для знака), просто удвойтесь 2^30 для получения приблизительно 2 миллиардов. Для неподписанного интервала с помощью 32 битов, дважды снова для 4 миллиардов. Ошибочный фактор становится выше большее, Вы идете, конечно, но Вам не нужно точное запоминаемое значение (При необходимости в нем необходимо использовать предопределенную константу для него так или иначе). Приближенное значение достаточно хорошо для того, чтобы замечать, когда что-то могло бы быть опасно близко к переполнению.

Самый корректный ответ, о котором я могу думать, Int32.MaxValue .

Это — 10 цифр, поэтому притворитесь, что это — номер телефона (предполагающий, что Вы находитесь в США). 214-748-3647. Я не рекомендую назвать его.

Вместо того, чтобы думать о нем как об одном большом количестве, попытайтесь ломать его и искать связанные идеи, например:

• 2 максимальных снукерных повреждения (максимальное повреждение равняется 147)
• 4 года (48 месяцев)
• 3 года (36 месяцев)
• 4 года (48 месяцев)

Вышеупомянутое относится к самому большому отрицательному числу; положительный это минус одно.

, Возможно, вышеупомянутая разбивка будет не более незабываема для Вас (это едва захватывающе, он!), но надо надеяться можно придумать некоторые идеи, которые являются!

Самое большое отрицательное (32-битное) значение: -2147483648
(1

Так, 2^31 (подписанный интервал макс.) 2^30 (приблизительно 1 миллиард) времена 2^1 (2), или приблизительно 2 миллиарда. И 2^32 2^30 * 2^2 или приблизительно 4 миллиарда. Этот метод приближения достаточно точен, выравниваются к приблизительно 2^64 (где ошибка растет приблизительно до 15%).

при необходимости в точном ответе тогда необходимо потянуть калькулятор.

Удобные выровненные словом полные приближения:

= 64 тысячи//uint16
2^32

= 4 миллиарда//uint32, IPv4, unixtime
2^64

= 16 квинтильонов (иначе 16 миллиардов миллиардов или 16 миллионов триллионов)//uint64, "bigint"
2^128

= 256 квинтильонов квинтильона (иначе 256 триллионов триллионов триллионов)//IPv6, GUID

Просто примите любой достойный калькулятор и тип "7FFFFFFF" в шестнадцатеричном режиме, затем переключитесь на десятичное число.

Вот мнемоника для запоминания 2 ** 31, вычтите единицу, чтобы получить максимальное целочисленное значение.

a = 1, b = 2, c = 3, d = 4, e = 5, f = 6, g = 7, h = 8, i = 9

использовал способности от двух до 18 достаточно часто, чтобы помнить их, но даже я не удосужился запомнить 2 ** 31. Это слишком легко рассчитать по мере необходимости или использовать константу, или оценить как 2G.

32 бита, один для знака, 31 бит информации:

Почему -1?
Поскольку первый равен нулю, поэтому наибольшее значение составляет минус один .

РЕДАКТИРОВАТЬ для cantfindaname88

Число 2 ^ 31, но наибольшее не может быть 2147483648 (2 ^ 31), потому что мы считаем от 0, а не 1.

Другое объяснение только с 3 битами: 1 для знака, 2 для информации

Ниже всех возможных значений с 3 битами: (2 ^ 3 = 8 значений)

Ну, он имеет 32 бита и, следовательно, может хранить 2 ^ 32 различных значений. Половина из них отрицательны.

Решение — 2 147 483 647

, а самое низкое — 2 147 483 648.

(Обратите внимание, что есть еще одно отрицательное значение.)

Самый простой способ сделать это для целых чисел — это использовать шестнадцатеричное при условии, что нет ничего похожего на Int.maxInt (). Причина заключается в следующем:

Макс. Значения без знака

Значения со знаком, используя 7F в качестве максимального значения со знаком

Значения со знаком, используя 80 в качестве максимального значение со знаком

Как это работает? Это очень похоже на двоичную тактику, и каждая шестнадцатеричная цифра составляет ровно 4 бита. Кроме того, многие компиляторы поддерживают hex намного лучше, чем двоичный.

Таким образом, 7F равно 01111111 / 7FFF равно 0111111111111111. Кроме того, если вы используете это для «безумно высокой константы», 7F . является безопасным гексом, но достаточно легко попробуйте 7F и 80 и просто распечатайте их на экране, чтобы увидеть, какой это.

0x7FFF + 0x0001 = 0x8000, поэтому ваша потеря составляет всего одно число, поэтому использование 0x7F . обычно не является плохим компромиссом для более надежного кода, особенно после того, как вы начнете использовать 32-разрядные или более

Сначала напишите 47 дважды, (вам нравится Агент 47 , верно?), Оставляя пробелы, как показано (каждая черта — это слот для одной цифры. Сначала 2 слота, затем 4)

Думаю, у вас есть 12 в руке (потому что 12 = дюжина). Умножьте его на 4 , первую цифру номера агента 47, то есть 47 , и поместите результат справа от первой пары, которая у вас уже есть

Затем умножьте 12 на 3 (чтобы сделать вторую цифру номера Агента 47, то есть 7 , вам нужно 7 — 4 = 3 ) и поместить результат справа от первых 2 пар, последней пары слотов

Наконец, перетащите цифры одну за другой из вашей руки, начиная с самой правой цифры (в данном случае 2), и поместите их в первое пустое место, которое вы получите

Вот оно! Для отрицательного предела вы можете думать об этом как о 1 больше в абсолютном значении , чем положительном пределе.

Попрактикуйтесь несколько раз, и вы освоите это!