Числа с плавающей запятой фиксированной ширины в C/С++

int обычно составляет 32 бита, но в стандарте int не гарантируется постоянная ширина. Поэтому, если мы хотим 32-битный int, мы включаем stdint.h и используем int32_t.

Есть ли эквивалент для этого для float? Я понимаю это немного сложнее с поплавками, поскольку они не хранятся однородным образом, то есть знак, показатель, значимость. Я просто хочу, чтобы double гарантированно хранился в 64 битах с 1 знаковым битом, 10-битным показателем и значительным значением 52/53 бит (в зависимости от того, подсчитываете ли вы скрытый бит).

Ответ 1

В соответствии с текущий проект стандарта C99, приложение F, которое должно быть двойным. Конечно, это предполагает, что ваши компиляторы соответствуют той части стандарта.

Для С++ я проверил проект 0x и проект для версии стандарта 1998 года, но ни один из них не указывает ничего о представлении, как эта часть стандарта C99, за пределами bool в numeric_limits, который указывает, что IEEE 754/IEC 559 используется на этой платформе, как упоминает Джош Келли.

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

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

Ответ 2

Пока я не знаю типа, который гарантирует определенный размер и формат, у вас есть несколько вариантов на С++. Вы можете использовать заголовок <limits> и его std::numeric_limits шаблон класса, чтобы узнать размер данного типа, std::numeric_limits::digits сообщает вам количество бит в мантиссе и std::numeric_limits::is_iec559 должно указать, следует ли тип в формате IEEE. (Пример кода, который обрабатывает номера IEEE на уровне бит, см. В шаблоне класса FloatingPoint в Google Test gtest-internal.h.)

Ответ 3

Другая проблема - представление чисел с плавающей запятой. Обычно это зависит от оборудования, на котором вы работаете (но не всегда). Большинство систем используют стандарты IEEE 754 Float point, но другие могут также иметь свои собственные стандарты (примером может служить компьютер VAX).

Википедия объясняет IEEE 754 http://en.wikipedia.org/wiki/IEEE_754-2008

Ответ 4

Там нет изменений в float/double, о которых я знаю. Float имеет 32 бита на века, а double - 64. Семантика с плавающей запятой довольно сложна, но существуют константы в

#include <limits>

boost.numeric.bounds - более простой интерфейс, если вам не нужно все в std:: numeric_limits

Ответ 5

К сожалению, это тоже не гарантировано. Вы должны проверить numeric_limits< T > в <limits>.

Но опять же, я никогда не слышал о реализации, где double не был 64 бит в длину. Если бы вы хотели просто предположить, вы бы, возможно, сойти с рук.

Ответ 6

Одна из самых больших проблем с этими типами "фиксированной ширины" заключается в том, что так легко ошибиться. Вероятно, вы не хотели бы 32-битного целого числа. Какой смысл? Что вы хотите - это целочисленный тип, который может хранить как минимум 1 → 31. Это long int. Вам даже не нужно <stdint.h> для этого.

Аналогично, ваш язык сценариев может реализовывать тип FP, который будет работать до тех пор, пока базовый С++ float будет не менее 32 бит. Обратите внимание, что это все еще не дает вам точного поведения. Я уверен, что С++ не гарантирует -1.0/-3.0==1.0/3.0