Есть ли суффикс литерала с плавающей запятой в С++, чтобы сделать двойную точность?

В настоящее время я работаю над проектом С++, который выполняет численные вычисления. Огромное, подавляющее большинство кода использует значения одинарной точности с плавающей запятой и прекрасно работает с этим. Из-за этого я использую флаги компилятора, чтобы сделать базовую литературу с плавающей запятой одинарной точностью вместо двойной точности, которая по умолчанию. Я нахожу, что это облегчает чтение, и мне не нужно беспокоиться о том, чтобы забыть "f" где-то. Тем не менее, время от времени мне нужна дополнительная точность, предлагаемая вычислениями с двойной точностью, и мой вопрос заключается в том, как я могу получить литерал с двойной точностью в такое выражение. Каждый путь, который я пробовал до сих пор, сначала сохраняет значение в одной переменной точности и преобразует усеченное значение в значение двойной точности. Не то, что я хочу.

Некоторые способы, которые я пробовал до сих пор, приведены ниже.

#include <iostream>

int main()
{
  std::cout << sizeof(1.0E200) << std::endl;
  std::cout << 1.0E200 << std::endl;

  std::cout << sizeof(1.0E200L) << std::endl;
  std::cout << 1.0E200L << std::endl;

  std::cout << sizeof(double(1.0E200)) << std::endl;
  std::cout << double(1.0E200) << std::endl;

  std::cout << sizeof(static_cast<double>(1.0E200)) << std::endl;
  std::cout << static_cast<double>(1.0E200) << std::endl;

  return 0;
}

Запуск с константами одиночной точности дает следующие результаты.

~/path$ g++ test.cpp -fsingle-precision-constant && ./a.out
test.cpp:6:3: warning: floating constant exceeds range of ‘float’ [-Woverflow]
test.cpp:7:3: warning: floating constant exceeds range of ‘float’ [-Woverflow]
test.cpp:12:3: warning: floating constant exceeds range of ‘float’ [-Woverflow]
test.cpp:13:3: warning: floating constant exceeds range of ‘float’ [-Woverflow]
test.cpp:15:3: warning: floating constant exceeds range of ‘float’ [-Woverflow]
test.cpp:16:3: warning: floating constant exceeds range of ‘float’ [-Woverflow]
4
inf
16
1e+200
8
inf
8
inf

Я понимаю, что 8 байтов, предоставленных в последних двух случаях, должно быть достаточно, чтобы провести 1.0E200, теорию, поддерживаемую следующим выходом, где одна и та же программа скомпилирована без -fsingle-precision-constant.

~/path$ g++ test.cpp  && ./a.out
8
1e+200
16
1e+200
8
1e+200
8
1e+200

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

Что еще я могу сделать?

ОТВЕТЫ

Ответ 1

Как сказал Марк, в стандарте говорится, что его двойной, если только его не следует f.

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

Итак, правильный подход:

  • Удалить флаг компилятора
  • Исправить все предупреждения о потере точности при сохранении двойных значений в переменных с плавающей запятой (добавить все суффиксы f)
  • Когда вам нужно удвоить, опустите суффикс f.

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

Ответ 2

Если вы прочитали 2.13.3/1, вы увидите:

Тип плавающего литерала является двойным, если явно не указано суффиксом. Суффиксы f и F задают float, суффиксы l и L укажите длинный двойной.

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

Ответ 3

Если вы можете позволить себе GCC 4.7 или Clang 3.1, используйте пользовательский литерал:

double operator "" _d(long double v) { return v; }

Использование:

std::cout << sizeof(1.0E200_d) << std::endl;
std::cout << 1.0E200_d << std::endl;

Результат:

8
1e+200

Ответ 4

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

#define D(x) (double(x##L))

будет работать для вас. Компилятор должен просто испустить двойную константу и, по-видимому, с -O2 в моей системе.