Как отформатировать двойники следующим образом?

Программа не может ЗНАТЬ, как форматировать числа так, как вы описываете, если только вы не напишете код для анализа чисел каким-то образом, и даже это может быть довольно сложно.

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

Одна альтернатива, которая может работать, состоит в том, чтобы выводить в stringstream, а затем изменять вывод, удаляя конечные нули. Что-то вроде этого:

string obvious_format_attempt2( double d )
{
    stringstream ss;
    ss.precision(15);
    ss << fixed;
    ss << d;
    string res = ss.str();
    // Do we have a dot?
    if ((string::size_type pos = res.rfind('.')) != string::npos)
    {
       while(pos > 0 && (res[pos] == '0' || res[pos] == '.')
       {
           pos--;
       }
       res = res.substr(pos);
    }
    return res;
}

На самом деле я не устал от этого, но как грубый набросок он должен работать. Предостережение заключается в том, что если у вас есть что-то вроде 0,1, оно может быть напечатано как 0,099999999999999285 или что-то в этом роде, потому что 0,1 не может быть представлено в точной форме как двоичный файл.

Точное форматирование двоичных чисел с плавающей запятой довольно сложно и традиционно ошибочно. Пара статей, опубликованных в 1990 году в том же журнале, установила, что десятичные значения, преобразованные в двоичные числа с плавающей запятой и обратно, могут быть восстановлены, если предположить, что они не используют больше десятичных цифр, чем определенное ограничение (в C++, представленном с использованием std::numeric_limits<T>::digits10 для соответствующий тип T):

• "Как правильно читать числа с плавающей запятой" Клингера описывает алгоритм преобразования десятичного представления в двоичное с плавающей запятой.
• "Как точно печатать числа с плавающей запятой" Стил/Уайт описывает, как преобразовать из двоичного числа с плавающей запятой в десятичное десятичное значение. Интересно, что алгоритм преобразует даже в кратчайшее такое десятичное значение.

На момент публикации этих документов директивы форматирования C для двоичных чисел с плавающей запятой ("%f", "%e" и "%g") были хорошо известны, и они не претерпели изменений, чтобы учесть новые результаты. Проблема со спецификацией этих директив форматирования заключается в том, что "%f" предполагает подсчет цифр после запятой, и нет спецификатора формата, запрашивающего форматирование чисел с определенным количеством цифр, но не обязательно начиная отсчет с десятичной запятой (например, для форматирования с десятичной точкой, но потенциально с большим количеством начальных нулей).

Спецификаторы формата до сих пор не улучшены, например, чтобы включить еще один для ненаучной записи, возможно, включающей много нулей, если на то пошло. По сути, мощь алгоритма Стила/Уайта раскрыта не полностью. Форматирование C++, к сожалению, не улучшило ситуацию и просто делегирует семантику директивам форматирования C.

Подход, при котором не устанавливается std::ios_base::fixed и используется точность std::numeric_limits<double>::digits10, является наиболее близким приближением к форматированию с плавающей запятой, которое предлагают стандартные библиотеки C и C++. Точный запрошенный формат может быть получен путем получения цифр с помощью форматирования с помощью std::ios_base::scientific, анализа результата и последующей перезаписи цифр. Чтобы придать этому процессу приятный потоковый интерфейс, его можно инкапсулировать с помощью фасета std::num_put<char>.

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

Вы не можете делать то, что хотите, потому что десятичные числа не могут быть точно представлены в формате с плавающей запятой. Другими словами, double не может точно содержать 3.14, он хранит все в виде долей степени двойки, поэтому он сохраняет это как что-то вроде 3 + 9175/65536 или около того (сделайте это на своем калькуляторе, и вы получите 3,1399993896484375. ( Я понимаю, что 65536 не является правильным знаменателем для IEEE double, но суть его верна).

Это известно как проблема кругового пути. Вы не можете надежно сделать

double x = 3.14;
cout << magic << x;

и получите "3.14"

Если вы должны решить проблему кругового пути, не используйте плавающую точку. Используйте пользовательский «десятичный» класс или используйте строку для хранения значения.

Вот десятичный класс, который вы могли бы использовать: https://stackoverflow.com/a/15320495/364818

Я использую С++, и я хотел бы отформатировать двойные числа следующим очевидным образом.

Основываясь на ваших образцах, я предполагаю, что вы хотите

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

Следующая функция делает именно это:

    #include <cmath>
    #include <iomanip>
    #include <sstream>
    #include <string>


    std::string fixed_precision_string (double num) {

        // Magic numbers
        static const int prec_limit = 14;       // Change to 15 if you wish
        static const double log10_fuzz = 1e-15; // In case log10 is slightly off
        static const char decimal_pt = '.';     // Better: use std::locale

        if (num == 0.0) {
            return "0";
        }

        std::string result;

        if (num < 0.0) {
            result = '-';
            num = -num;
        }

        int ndigs = int(std::log10(num) + log10_fuzz);
        std::stringstream ss;
        if (ndigs >= prec_limit) {
            ss << std::fixed
               << std::setprecision(0)
               << num;
            result += ss.str();
        }
        else {
            ss << std::fixed
               << std::setprecision(prec_limit-ndigs)
               << num;
            result += ss.str();
            auto last_non_zero = result.find_last_not_of('0');
            if (result[last_non_zero] == decimal_pt) {
                result.erase(last_non_zero); 
            }
            else if (last_non_zero+1 < result.length()) {
                result.erase(last_non_zero+1);
            }
        }
        return result;
    }

Если вы используете компьютер, использующий IEEE с плавающей запятой, изменение prec_limit на 16 нежелательно. Хотя это позволит вам правильно напечатать 0,99999999999999999 как таковое, оно также напечатает 5.1 как 5,0999999999999996 и 9,99999998 как 9,9999999800000001. Это с моего компьютера, ваши результаты могут отличаться из-за другой библиотеки.

Изменение prec_limit на 15 допустимо, но это все равно приводит к тому, что числа печатаются «неправильно». Указанное значение (14) прекрасно работает, пока вы не пытаетесь напечатать 1.0-1e-15.

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