Насколько велика может быть 64-разрядное целое число без знака?

Вопрос: Я совершенно ясно понимаю, насколько велика 64-битное целое число со знаком? Благодаря этому вопросу и его прямым ответам. Итак, согласно этому, могу ли я сказать, что unsigned int может быть 2 ^ 64 - 1, а не 2 ^ 63 - 1? 2^63 - 1: 0111111111111111111111111111111111111111111111111111111111111111 2^64 - 1: 1111111111111111111111111111111111111111111111111111111111111111 Если и только если

Вопрос:

Я совершенно ясно понимаю, насколько велика 64-битное целое число со знаком? Благодаря этому вопросу и его прямым ответам.

Итак, согласно этому, могу ли я сказать, что unsigned int может быть 2 ^ 64 – 1, а не 2 ^ 63 – 1?

2^63 — 1: 0111111111111111111111111111111111111111111111111111111111111111 2^64 — 1: 1111111111111111111111111111111111111111111111111111111111111111

Если и только если я правильно понял, как я могу обнаружить неподписанное переполнение? Переполнение знакового целого в двух представлениях дополнения будет вторгаться в самую высокую позицию бита, возвращая отрицательное число. Но как насчет этого неподписанного случая?

Лучший ответ:

Это трудно или невозможно обнаружить, посмотрев на ценность.
Проблема заключается в том, что максимальное значение плюс даже только 1 остается/снова действительным значением; т.е. 0.

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

Если вы вычислите, например, c=a+b; (a, b, c – это 64-битные без знака int и a, b, которые находятся близко друг к другу с max или migth) и хотят выяснить, влияет ли результат,
затем проверьте, ((max — b) < a); причем max является соответствующим символом, предоставленным компилятором.

Не рассчитывайте максимальное значение самостоятельно как 2 ^ 64-1, оно будет специфичным для реализации и зависит от платформы. Кроме того, он будет содержать обход дважды (2 ^ 64 за макс, возможно, 0, и вычитание 1 происходит через 0 назад…). И это применяется, даже если ^ понимается как подходящая версия “для власти”.

Ответ №1

Подписанное целое число может 2^63-1 (9,223,372,036,854,775,807), потому что бит наивысшего значения зарезервирован для знака. Если этот бит равен 1 число отрицательно и может быть ниже -2^63 (-9, 223,372,036,854,775,808).

В подписанном 64-битном целом, 2^64-1 на самом деле является номером -1.

Однако если вы используете целые числа без знака, значение начинается с 0 и 2^64-1 (18,446,744,073,709,551,615), становится его самым высоким значением, но целые числа без знака не могут представлять отрицательные значения.

Ответ №2

Насколько велика 64 бит?

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

Считайте от 0 до максимального значения, которое можно сохранить в переменной. Первый раз использовать 32-битную переменную и вторую раз использовать переменную шириной 64 бит. Попытайтесь оценить результаты.

В С# код может выглядеть так для 32-битной переменной (… игнорировать, пожалуйста, отключить по одной проблеме):

for (uint i = 0; i < uint.MaxValue; i++) { Process(i); }

uint.MaxValue – это число, которое вы получаете, когда вы устанавливаете все биты переменной в 1. Она в основном равна 2 ^ 32 – 1 = 4294967295. Это около 4,2 миллиарда.

Код проверки для случая с 64-битной переменной похож:

for (ulong i = 0; i < ulong.MaxValue; i++) { Process(i); }

ulong.MaxValue – это время 2 ^ 64 – 1 = 18446744073709551615 (20-значное число).

Приблизительно 1 миллиард операций() операций/вторых, первая программа завершит свою работу в:

2 ^ 32/1000000000 = 4,29 секунды

При той же скорости обработки вторая программа завершит свою работу в:

2 ^ 64/1000000000/3600/24/365 = 585 лет!

Это отличная разница !!! У кого есть время подождать 585 лет для того, чтобы закончить свою работу!

И забавная часть состоит в том, что 1 миллиард операций в секунду довольно агрессивный! Для более реалистичного сценария, в котором вы выполняете от 1 миллиона до нескольких сотен миллионов операций в секунду, время взрывается до тысяч даже сотен тысяч лет, чтобы сделать сингл для!

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

Другие большие числа

Помните, что максимальное число, хранящееся в 64-битном регистре/переменной, составляет 2 ^ 64 – 1 = 18446744073709551615 (20-значное число). По большому счету, это количество по-прежнему мало по сравнению с 1 googol, которое составляет 10 ^ 100 (1 за которым следует 100 нулей)!

И даже большой гогол меньше 70! (70 факториал 1 * 2 *… * 70). Вот Это Да! Это действительно показывает силу умножения!

И вы знаете, что: googol находится в пределах диапазона двойного типа данных (IEEE 754 с плавающей запятой) – также 64-битная структура. Как удвоить объем хранения таких больших чисел будет представлен в следующей статье.

Я надеюсь, тебе было весело!

Ответ №3

Ваше предположение о максимальном размере целых чисел с подписью и без знака является правильным. Фактические значения – 9223372036854775807 для подписанных и 18446744073709551615 для неподписанных.

Обнаружение переполнения для беззнакового добавления довольно просто – если результат меньше, чем один из операндов, произошло переполнение.

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

Умножение жесткое, я не знаю простого правила для этого.

Переполнение невозможно для деления, если вы не разделите его на ноль.

Ответ №4

Насколько велика может быть 64-разрядное целое число без знака?

Чтобы UINT64_MAX максимум, лучше всего использовать UINT64_MAX. Он всегда определен, когда доступен 64-битный тип.

#include <stdint.h> #define MAX64BIT UINT64_MAX or #define MAX64BIT 0xFFFFFFFFFFFFFFFF or #define MAX64BIT 18446744073709551615u

как я могу обнаружить неподписанное переполнение?

С N-разрядными беззнаковыми типами: uintN_t a,b;

Обнаружение переполнения:

// addition uintN_t sum = a + b; bool overflow = sum < a; // or sum < b // subtraction bool overflow = b > a; uintN_t diff = a — b; //

Из-за неопределенного поведения (UB) подписанной математики требуется другой код с подписанными типами. пример

Ответ №5

Это может быть 18446744073709551615.

18,446,744,073,709,551,615 q5 q4 t b m t h

Оцените статью
Добавить комментарий