Início / coding / Perguntas / 79350589
Accepted
user877329
Asked: 2025-01-13 03:42:21 +0800 CST

std::format especifica o número de dígitos significativos, mas nunca muda para a notação "e"

  • 772

Preciso formatar valores com 2 dígitos significativos, mas nunca usar a notação "e".

Saída esperada:

9.3
6.6
4.6
3.2
2.3
1.6
1.1
760
520
340
200
96
0

123456 deve ser impresso como 120000. 0,123456 deve ser impresso como 0,12

Para contexto, ele usa prefixos SI para cada fator 10^3. Tentei

std::format("{:.2g}", value);

Mas ele decide sozinho quando mudar para a notação "e":

9.3
6.6
4.6
3.2
2.3
1.6
1.1
7.6e+02
5.2e+02
3.4e+02
2e+02
96
0

Observação: estou pedindo especificamente um método que não use stringstream.

Nota: usar fo especificador de formato é errado. Ele produz 2 dígitos após o ponto decimal, o que não é correto:

9.35
6.56
4.60
3.22
2.26
1.58
1.10
760.33
517.10
339.48
204.91
96.35
0.00

Aqui está um exemplo mínimo reproduzível (com vários valores)

#include <array>
#include <cstdio>
#include <format>

static constexpr std::array<float, 25> vals{
    9349.3867f,
    6558.6953f,
    4600.0f,
    3224.8362f,
    2258.7588f,
    1579.2142f,
    1099.9999f,
    760.32617f,
    517.10278f,
    339.47632f,
    204.91417f,
    96.3461f,
    0.0f,
    -96.346039f,
    -204.91402f,
    -339.47632f,
    -517.10266f,
    -760.32574f,
    -1099.9999f,
    -1579.2134f,
    -2258.7578f,
    -3224.8362f,
    -4599.9985f,
    -6558.6938f,
    -9349.3867f
};

int main()
{
    for(size_t k = 0; k != std::size(vals); ++k)
    {
        // None of these produce the expected result
        puts(std::format("{:.2g}\n", vals[k]).c_str());
        puts(std::format("{:.1e}\n", vals[k]).c_str());
        puts(std::format("{:.2f}\n", vals[k]).c_str());
    }
}
c++

1 respostas

  1. Best Answer

    std::formatcontrola como tipos básicos (como float) são formatados, e sua exigência não é possível com o que ele permite em sua especificação de formato (que é basicamente como a especificação de formato do Python funciona).

    você pode, no entanto, criar seu próprio tipo cujo formatador segue quaisquer regras que você queira impor; seus requisitos específicos de 2 dígitos significativos podem ser atendidos com o seguinte formatador constexpr.

    #include <iostream>
#include <format>
#include <charconv>

struct Truncate
{
    double value;
};

template<>
struct std::formatter<Truncate, char>
{
    template<class ParseContext>
    constexpr ParseContext::iterator parse(ParseContext& ctx)
    {
        return ctx.begin();
    }

    template<class FmtContext>
    constexpr FmtContext::iterator format(Truncate s, FmtContext& ctx) const
    {
        char buffer[16]{};
        auto result = std::to_chars(buffer, buffer + std::size(buffer), s.value, std::chars_format::general, 2);
        std::string_view str{ buffer, result.ptr };
        auto out_it = ctx.out();
        if (auto plus_pos = str.find('+'); plus_pos != str.npos)
        {
            int zeros = 0;
            auto zeros_view = str.substr(plus_pos + 1);
            std::from_chars(zeros_view.data(), zeros_view.data() + zeros_view.size(), zeros);
            bool has_dot = str.find('.') != str.npos;
            if (str[0] != '-')
            {
                *out_it++ = str[0];
                if (has_dot)
                {
                    *out_it++ = str[2];
                }
            }
            else
            {
                *out_it++ = '-';
                *out_it++ = str[1];
                if (has_dot)
                {
                    *out_it++ = str[3];
                }
            }
            if (!has_dot)
            {
                *out_it++ = '0';
            }
            for (int i = 1; i < zeros; i++)
            {
                *out_it++ = '0';
            }
            return out_it;
        }
        else if (auto neg_pos = str.rfind('-'); neg_pos != 0 && neg_pos != str.npos)
        {
            int zeros = 0;
            auto zeros_view = str.substr(neg_pos + 1);
            std::from_chars(zeros_view.data(), zeros_view.data() + zeros_view.size(), zeros);
            bool has_dot = str.find('.') != str.npos;

            if (str[0] == '-')
            {
                *out_it++ = '-';
            }
            *out_it++ = '0';
            *out_it++ = '.';
            for (int i = 1; i < zeros; i++)
            {
                *out_it++ = '0';
            }
            if (str[0] != '-')
            {
                *out_it++ = str[0];
                if (has_dot)
                {
                    *out_it++ = str[2];
                }
            }
            else
            {
                *out_it++ = str[1];
                if (has_dot)
                {
                    *out_it++ = str[3];
                }
            }
            return out_it;
        }
        return std::ranges::copy(std::move(str), ctx.out()).out;
    }
};

int main(int argc, char** argv)
{
    {
        double value = 7623;
        auto str = std::format("{} ", Truncate{ value });
        std::cout << value << " -> " << str << '\n';
    }
    {
        double value = -0.0123456;
        auto str = std::format("{}", Truncate{ value });
        std::cout << value <<  " -> " << str << '\n';
    }

    {
        double value = 0;
        auto str = std::format("{}", Truncate{ value });
        std::cout << value <<  " -> " << str << '\n';
    }

    {
        double value = 1.2;
        auto str = std::format("{}", Truncate{ value });
        std::cout << value <<  " -> " << str << '\n';
    }
    {
        double value = 12;
        auto str = std::format("{}", Truncate{ value });
        std::cout << value <<  " -> " << str << '\n';
    }
    {
        double value = 0.12;
        auto str = std::format("{}", Truncate{ value });
        std::cout << value <<  " -> " << str << '\n';
    }
}

    demonstração godbolt

    7623 -> 7600
-0.000123456 -> -0.00012
0 -> 0
1.2 -> 1.2
12 -> 12
0.12 -> 0.12

    Este formatador é quase 1,5 vez mais rápido do que std::formatem um double, mas não lida com localidade, largura ou alinhamento. (A localidade seria facilmente resolvida fazendo a conversão de localidade somente ao gravar na saída.)

    • 4

relate perguntas