Evite zeros à direita em printf ()


107

Eu continuo tropeçando nos especificadores de formato para a família de funções printf (). O que eu quero é poder imprimir um double (ou float) com um número máximo de dígitos após a vírgula decimal. Se eu usar:

printf("%1.3f", 359.01335);
printf("%1.3f", 359.00999);

eu recebo

359.013
359.010

Em vez do desejado

359.013
359.01

Alguém pode me ajudar?


1
A inexatidão do ponto flutuante realmente significa que você mesmo deve fazer o arredondamento. Pegue uma variante da resposta de R e Juha (que não lida bem com os zeros à direita) e corrija-a.
wnoise

Respostas:


88

Isso não pode ser feito com os printfespecificadores de formato normal . O mais próximo que você poderia chegar seria:

printf("%.6g", 359.013); // 359.013
printf("%.6g", 359.01);  // 359.01

mas o ".6" é a largura numérica total, então

printf("%.6g", 3.01357); // 3.01357

quebra.

O que você pode fazer é transferir sprintf("%.20g")o número para um buffer de string e manipular a string para ter apenas N caracteres após o ponto decimal.

Supondo que seu número esteja na variável num, a função a seguir removerá todos, exceto os primeiros Ndecimais e, em seguida, removerá os zeros à direita (e o ponto decimal se todos fossem zeros).

char str[50];
sprintf (str,"%.20g",num);  // Make the number.
morphNumericString (str, 3);
:    :
void morphNumericString (char *s, int n) {
    char *p;
    int count;

    p = strchr (s,'.');         // Find decimal point, if any.
    if (p != NULL) {
        count = n;              // Adjust for more or less decimals.
        while (count >= 0) {    // Maximum decimals allowed.
             count--;
             if (*p == '\0')    // If there's less than desired.
                 break;
             p++;               // Next character.
        }

        *p-- = '\0';            // Truncate string.
        while (*p == '0')       // Remove trailing zeros.
            *p-- = '\0';

        if (*p == '.') {        // If all decimals were zeros, remove ".".
            *p = '\0';
        }
    }
}

Se você não estiver satisfeito com o aspecto de truncamento (que se transformaria 0.12399em, em 0.123vez de arredondá-lo 0.124), pode usar os recursos de arredondamento já fornecidos por printf. Você só precisa analisar o número de antemão para criar dinamicamente as larguras e usá-las para transformar o número em uma string:

#include <stdio.h>

void nDecimals (char *s, double d, int n) {
    int sz; double d2;

    // Allow for negative.

    d2 = (d >= 0) ? d : -d;
    sz = (d >= 0) ? 0 : 1;

    // Add one for each whole digit (0.xx special case).

    if (d2 < 1) sz++;
    while (d2 >= 1) { d2 /= 10.0; sz++; }

    // Adjust for decimal point and fractionals.

    sz += 1 + n;

    // Create format string then use it.

    sprintf (s, "%*.*f", sz, n, d);
}

int main (void) {
    char str[50];
    double num[] = { 40, 359.01335, -359.00999,
        359.01, 3.01357, 0.111111111, 1.1223344 };
    for (int i = 0; i < sizeof(num)/sizeof(*num); i++) {
        nDecimals (str, num[i], 3);
        printf ("%30.20f -> %s\n", num[i], str);
    }
    return 0;
}

Todo o ponto de nDecimals(), neste caso, é trabalhar corretamente as larguras de campo, em seguida, formatar o número usando uma seqüência de formato com base nisso. O equipamento de teste main()mostra isso em ação:

  40.00000000000000000000 -> 40.000
 359.01335000000000263753 -> 359.013
-359.00999000000001615263 -> -359.010
 359.00999999999999090505 -> 359.010
   3.01357000000000008200 -> 3.014
   0.11111111099999999852 -> 0.111
   1.12233439999999995429 -> 1.122

Depois de ter o valor arredondado corretamente, você pode mais uma vez passá-lo para morphNumericString()para remover os zeros finais simplesmente alterando:

nDecimals (str, num[i], 3);

para dentro:

nDecimals (str, num[i], 3);
morphNumericString (str, 3);

(ou chamando morphNumericStringno final de nDecimals, mas, nesse caso, provavelmente combinaria os dois em uma função), e você terminaria com:

  40.00000000000000000000 -> 40
 359.01335000000000263753 -> 359.013
-359.00999000000001615263 -> -359.01
 359.00999999999999090505 -> 359.01
   3.01357000000000008200 -> 3.014
   0.11111111099999999852 -> 0.111
   1.12233439999999995429 -> 1.122

8
Observe que esta resposta pressupõe que a casa decimal é .Em alguns locais, a casa decimal é na verdade uma ,vírgula.

1
Na verdade, há um pequeno erro de digitação aqui - p = strchr (str, '.'); deve ser p = strchr (s, '.'); Para usar a função param em vez da var global.
n3wtz

Usar muitos dígitos pode gerar resultados inesperados ... por exemplo, "% .20g" com 0,1 exibirá lixo. O que você precisa fazer se não quiser surpreender os usuários é começar com, digamos, 15 dígitos e continuar incrementando até atofretornar o mesmo valor.
6502

@ 6502, isso é porque não existe 0,1 no IEEE754 :-) No entanto, isso não causará problemas (pelo menos para esse valor), pois o resultado 0.10000000000000000555será 0.1quando retirado. O problema pode surgir se você tiver um valor ligeiramente abaixo, como se a representação mais próxima de 42.1fosse 42.099999999314159. Se você realmente quiser lidar com isso, provavelmente precisará arredondar com base no último dígito removido, em vez de truncar.
paxdiablo

1
@paxdiablo: Não há necessidade de criar dinamicamente uma string de formato para printffunções semelhantes a-como elas já suportam parâmetros dinâmicos ( *caractere especial): por exemplo, printf("%*.*f", total, decimals, x);gera um número com o comprimento total do campo especificado dinamicamente e decimais.
6502

54

Para se livrar dos zeros à direita, você deve usar o formato "% g":

float num = 1.33;
printf("%g", num); //output: 1.33

Depois que a questão foi esclarecida um pouco, suprimir zeros não é a única coisa que foi feita, mas também foi necessário limitar a saída a três casas decimais. Acho que isso não pode ser feito apenas com strings de formato sprintf. Como Pax Diablo apontou, a manipulação das cordas seria necessária.


Consulte a página de ajuda do MSDN: msdn.microsoft.com/en-us/library/0ecbz014(VS.80).aspx
xtofl

@Tomalak: Isso não faz o que eu quero. Quero ser capaz de especificar um número máximo de dígitos após a vírgula decimal. Este é: Eu quero que 1.3347 seja impresso "1.335" e 1.3397 seja impresso "1.34" @xtofl: Eu já tinha verificado isso, mas ainda não consigo ver a resposta para meu problema
Gorpik

3
O autor deseja o estilo 'f' e não o estilo 'e'. 'g' pode usar o estilo 'e': Da documentação: O estilo e é usado se o expoente de sua conversão for menor que -4 ou maior ou igual à precisão.
Julien Palard

20

Gosto da resposta da R. ligeiramente ajustada:

float f = 1234.56789;
printf("%d.%.0f", f, 1000*(f-(int)f));

'1000' determina a precisão.

Potência para o arredondamento de 0,5.

EDITAR

Ok, esta resposta foi editada algumas vezes e eu perdi a noção do que estava pensando há alguns anos (e originalmente não preenchia todos os critérios). Portanto, aqui está uma nova versão (que preenche todos os critérios e trata os números negativos corretamente):

double f = 1234.05678900;
char s[100]; 
int decimals = 10;

sprintf(s,"%.*g", decimals, ((int)(pow(10, decimals)*(fabs(f) - abs((int)f)) +0.5))/pow(10,decimals));
printf("10 decimals: %d%s\n", (int)f, s+1);

E os casos de teste:

#import <stdio.h>
#import <stdlib.h>
#import <math.h>

int main(void){

    double f = 1234.05678900;
    char s[100];
    int decimals;

    decimals = 10;
    sprintf(s,"%.*g", decimals, ((int)(pow(10, decimals)*(fabs(f) - abs((int)f)) +0.5))/pow(10,decimals));
    printf("10 decimals: %d%s\n", (int)f, s+1);

    decimals = 3;
    sprintf(s,"%.*g", decimals, ((int)(pow(10, decimals)*(fabs(f) - abs((int)f)) +0.5))/pow(10,decimals));
    printf(" 3 decimals: %d%s\n", (int)f, s+1);

    f = -f;
    decimals = 10;
    sprintf(s,"%.*g", decimals, ((int)(pow(10, decimals)*(fabs(f) - abs((int)f)) +0.5))/pow(10,decimals));
    printf(" negative 10: %d%s\n", (int)f, s+1);

    decimals = 3;
    sprintf(s,"%.*g", decimals, ((int)(pow(10, decimals)*(fabs(f) - abs((int)f)) +0.5))/pow(10,decimals));
    printf(" negative  3: %d%s\n", (int)f, s+1);

    decimals = 2;
    f = 1.012;
    sprintf(s,"%.*g", decimals, ((int)(pow(10, decimals)*(fabs(f) - abs((int)f)) +0.5))/pow(10,decimals));
    printf(" additional : %d%s\n", (int)f, s+1);

    return 0;
}

E o resultado dos testes:

 10 decimals: 1234.056789
  3 decimals: 1234.057
 negative 10: -1234.056789
 negative  3: -1234.057
 additional : 1.01

Agora, todos os critérios foram atendidos:

  • o número máximo de decimais atrás de zero é fixo
  • os zeros finais são removidos
  • faz matematicamente certo (certo?)
  • funciona (agora) também quando o primeiro decimal é zero

Infelizmente, esta resposta é de duas linhas, pois sprintfnão retorna a string.


1
Isso não parece realmente eliminar os zeros à direita? Ele pode cuspir alegremente algo como 1.1000.
Dean J

A pergunta e minha resposta não são mais os originais ... Vou verificar mais tarde.
Juha,

1
Casos de teste com falha: 1.012 com formatador "% .2g" resultará em 1.012 em vez de 1.01.
wtl

@wtl Boa captura. Agora corrigido.
Juha

@Jeroen: Eu acho que os flutuadores também falham em algum ponto quando os números ficam maiores ... mas basicamente a conversão de tipos para long, long long ou int64 deve funcionar.
Juha,

2

Eu procuro a string (começando mais à direita) para o primeiro caractere no intervalo 1para 9(valor ASCII 49- 57) então null(definido para 0) cada caractere à direita dele - veja abaixo:

void stripTrailingZeros(void) { 
    //This finds the index of the rightmost ASCII char[1-9] in array
    //All elements to the left of this are nulled (=0)
    int i = 20;
    unsigned char char1 = 0; //initialised to ensure entry to condition below

    while ((char1 > 57) || (char1 < 49)) {
        i--;
        char1 = sprintfBuffer[i];
    }

    //null chars left of i
    for (int j = i; j < 20; j++) {
        sprintfBuffer[i] = 0;
    }
}

2

Que tal algo assim (pode ter erros de arredondamento e problemas de valor negativo que precisam de depuração, deixado como um exercício para o leitor):

printf("%.0d%.4g\n", (int)f/10, f-((int)f-(int)f%10));

É ligeiramente programático, mas pelo menos não obriga você a fazer qualquer manipulação de string.


1

Uma solução simples, mas que dá conta do recado, atribui um comprimento e uma precisão conhecidos e evita a chance de entrar no formato exponencial (o que é um risco quando você usa% g):

// Since we are only interested in 3 decimal places, this function
// can avoid any potential miniscule floating point differences
// which can return false when using "=="
int DoubleEquals(double i, double j)
{
    return (fabs(i - j) < 0.000001);
}

void PrintMaxThreeDecimal(double d)
{
    if (DoubleEquals(d, floor(d)))
        printf("%.0f", d);
    else if (DoubleEquals(d * 10, floor(d * 10)))
        printf("%.1f", d);
    else if (DoubleEquals(d * 100, floor(d* 100)))
        printf("%.2f", d);
    else
        printf("%.3f", d);
}

Adicione ou remova "outros" se quiser um máximo de 2 decimais; 4 decimais; etc.

Por exemplo, se você quiser 2 casas decimais:

void PrintMaxTwoDecimal(double d)
{
    if (DoubleEquals(d, floor(d)))
        printf("%.0f", d);
    else if (DoubleEquals(d * 10, floor(d * 10)))
        printf("%.1f", d);
    else
        printf("%.2f", d);
}

Se você deseja especificar a largura mínima para manter os campos alinhados, aumente conforme necessário, por exemplo:

void PrintAlignedMaxThreeDecimal(double d)
{
    if (DoubleEquals(d, floor(d)))
        printf("%7.0f", d);
    else if (DoubleEquals(d * 10, floor(d * 10)))
        printf("%9.1f", d);
    else if (DoubleEquals(d * 100, floor(d* 100)))
        printf("%10.2f", d);
    else
        printf("%11.3f", d);
}

Você também pode converter isso em uma função em que passa a largura desejada do campo:

void PrintAlignedWidthMaxThreeDecimal(int w, double d)
{
    if (DoubleEquals(d, floor(d)))
        printf("%*.0f", w-4, d);
    else if (DoubleEquals(d * 10, floor(d * 10)))
        printf("%*.1f", w-2, d);
    else if (DoubleEquals(d * 100, floor(d* 100)))
        printf("%*.2f", w-1, d);
    else
        printf("%*.3f", w, d);
}

Pegue d = 0.0001: então floor(d)é 0, então a diferença é maior que 0,000001, então DoubleEqualsé falso, então não usará o "%.0f"especificador: você verá zeros à direita de "%*.2f"ou "%*.3f". Portanto, não responde à pergunta.
Cœur

1

Encontrei problemas em algumas das soluções postadas. Eu montei isso com base nas respostas acima. Parece funcionar para mim.

int doubleEquals(double i, double j) {
    return (fabs(i - j) < 0.000001);
}

void printTruncatedDouble(double dd, int max_len) {
    char str[50];
    int match = 0;
    for ( int ii = 0; ii < max_len; ii++ ) {
        if (doubleEquals(dd * pow(10,ii), floor(dd * pow(10,ii)))) {
            sprintf (str,"%f", round(dd*pow(10,ii))/pow(10,ii));
            match = 1;
            break;
        }
    }
    if ( match != 1 ) {
        sprintf (str,"%f", round(dd*pow(10,max_len))/pow(10,max_len));
    }
    char *pp;
    int count;
    pp = strchr (str,'.');
    if (pp != NULL) {
        count = max_len;
        while (count >= 0) {
             count--;
             if (*pp == '\0')
                 break;
             pp++;
        }
        *pp-- = '\0';
        while (*pp == '0')
            *pp-- = '\0';
        if (*pp == '.') {
            *pp = '\0';
        }
    }
    printf ("%s\n", str);
}

int main(int argc, char **argv)
{
    printTruncatedDouble( -1.999, 2 ); // prints -2
    printTruncatedDouble( -1.006, 2 ); // prints -1.01
    printTruncatedDouble( -1.005, 2 ); // prints -1
    printf("\n");
    printTruncatedDouble( 1.005, 2 ); // prints 1 (should be 1.01?)
    printTruncatedDouble( 1.006, 2 ); // prints 1.01
    printTruncatedDouble( 1.999, 2 ); // prints 2
    printf("\n");
    printTruncatedDouble( -1.999, 3 ); // prints -1.999
    printTruncatedDouble( -1.001, 3 ); // prints -1.001
    printTruncatedDouble( -1.0005, 3 ); // prints -1.001 (shound be -1?)
    printTruncatedDouble( -1.0004, 3 ); // prints -1
    printf("\n");
    printTruncatedDouble( 1.0004, 3 ); // prints 1
    printTruncatedDouble( 1.0005, 3 ); // prints 1.001
    printTruncatedDouble( 1.001, 3 ); // prints 1.001
    printTruncatedDouble( 1.999, 3 ); // prints 1.999
    printf("\n");
    exit(0);
}

1

Algumas das soluções mais votadas sugerem o %gespecificador de conversão de printf. Isso está errado porque há casos em %gque produzirá notação científica. Outras soluções usam matemática para imprimir o número desejado de dígitos decimais.

Acho que a solução mais fácil é usar sprintfcom o %fespecificador de conversão e remover manualmente os zeros à direita e possivelmente um ponto decimal do resultado. Aqui está uma solução C99:

#include <stdio.h>
#include <stdlib.h>

char*
format_double(double d) {
    int size = snprintf(NULL, 0, "%.3f", d);
    char *str = malloc(size + 1);
    snprintf(str, size + 1, "%.3f", d);

    for (int i = size - 1, end = size; i >= 0; i--) {
        if (str[i] == '0') {
            if (end == i + 1) {
                end = i;
            }
        }
        else if (str[i] == '.') {
            if (end == i + 1) {
                end = i;
            }
            str[end] = '\0';
            break;
        }
    }

    return str;
}

Observe que os caracteres usados ​​para dígitos e o separador decimal dependem do local atual. O código acima assume uma localidade C ou inglês dos EUA.


−0,00005 e 3 decimais resultarão em "−0" que pode ou não ser desejado. Além disso, talvez faça "3" um parâmetro para a conveniência dos outros?
golfinho

0

Aqui está minha primeira tentativa de resposta:

vazio
xprintfloat (formato char *, float f)
{
  char s [50];
  char * p;

  sprintf (s, formato, f);
  para (p = s; * p; ++ p)
    if ('.' == * p) {
      while (* ++ p);
      while ('0' == * - p) * p = '\ 0';
    }
  printf ("% s", s);
}

Bugs conhecidos: Possível estouro de buffer dependendo do formato. E se "." está presente por outro motivo que não% f pode ocorrer um resultado errado.


Seus bugs conhecidos são os mesmos que o printf () tem, então sem problemas. Mas eu estava procurando por uma string de formato que me permitisse fazer o que eu queria, não uma solução programática, que é o que eu já tenho.
Gorpik

0

Por que não fazer isso?

double f = 359.01335;
printf("%g", round(f * 1000.0) / 1000.0);

0

Ligeira variação acima:

  1. Elimina o período para o caso (10000,0).
  2. Interrupções após o processamento do primeiro período.

Codifique aqui:

void EliminateTrailingFloatZeros(char *iValue)
{
  char *p = 0;
  for(p=iValue; *p; ++p) {
    if('.' == *p) {
      while(*++p);
      while('0'==*--p) *p = '\0';
      if(*p == '.') *p = '\0';
      break;
    }
  }
}

Ele ainda tem potencial para transbordar, então tome cuidado; P


0

Eu diria que você deveria usar printf("%.8g",value);

Se você usar "%.6g", não obterá a saída desejada para alguns números como.32.230210, deve imprimir, 32.23021mas imprime32.2302


-2

Seu código é arredondado para três casas decimais devido ao ".3" antes de f

printf("%1.3f", 359.01335);
printf("%1.3f", 359.00999);

Portanto, se você arredondar a segunda linha para duas casas decimais, deverá alterá-la para:

printf("%1.3f", 359.01335);
printf("%1.2f", 359.00999);

Esse código produzirá os resultados desejados:

359.013
359.01

* Observe que isso pressupõe que você já tenha a impressão em linhas separadas; caso contrário, o seguinte irá impedi-la de imprimir na mesma linha:

printf("%1.3f\n", 359.01335);
printf("%1.2f\n", 359.00999);

O seguinte código-fonte do programa foi meu teste para esta resposta

#include <cstdio>

int main()
{

    printf("%1.3f\n", 359.01335);
    printf("%1.2f\n", 359.00999);

    while (true){}

    return 0;

}

4
A questão era sobre como criar uma string de formato que omitisse zeros à direita, para não ter strings de formato diferentes para cada caso.
Christoph Walesch
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.