Vermeiden Sie nachgestellte Nullen in printf()

Ich stolpere immer wieder über die Formatbezeichner für die Funktionsfamilie printf(). Was ich möchte, ist in der Lage zu sein, ein Double (oder Float) mit einer maximal gegebenen Anzahl von Ziffern nach dem Dezimalkomma zu drucken. Wenn ich verwende:

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

Ich bekomme

359.013
359.010

Anstelle des Gewünschten

359.013
359.01

Kann mir jemand helfen?

Das geht mit dem normalen nicht printf Formatbezeichner. Das nächste, was Sie bekommen könnten, wäre:

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

aber die “.6” ist die gesamt numerische Breite so

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

bricht es.

Was du kann tun ist zu sprintf("%.20g") die Zahl in einen String-Puffer und bearbeiten Sie dann den String so, dass er nur N Zeichen nach dem Dezimalkomma enthält.

Angenommen, Ihre Nummer befindet sich in der Variablen num, entfernt die folgende Funktion alle bis auf die erste N Dezimalstellen, entfernen Sie dann die nachgestellten Nullen (und den Dezimalpunkt, wenn sie alle Nullen waren).

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';
        }
    }
}

Wenn Sie mit dem Abschneideaspekt nicht zufrieden sind (was sich ändern würde 0.12399 hinein 0.123 anstatt es zu runden 0.124), können Sie die bereits von bereitgestellten Rundungsfunktionen verwenden printf. Sie müssen die Zahl nur vorher analysieren, um die Breiten dynamisch zu erstellen, und diese dann verwenden, um die Zahl in eine Zeichenfolge umzuwandeln:

#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;
}

Der springende Punkt von nDecimals() in diesem Fall ist es, die Feldbreiten korrekt zu berechnen und dann die Zahl mit einem darauf basierenden Formatstring zu formatieren. Der Prüfstand main() zeigt dies in Aktion:

  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

Sobald Sie den korrekt gerundeten Wert haben, können Sie diesen erneut an übergeben morphNumericString() um nachgestellte Nullen zu entfernen, indem Sie einfach Folgendes ändern:

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

hinein:

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

(Oder anrufen morphNumericString am Ende von nDecimals aber in diesem Fall würde ich wahrscheinlich nur die beiden zu einer Funktion kombinieren), und Sie erhalten am Ende:

  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

Um die abschließenden Nullen loszuwerden, sollten Sie das Format “%g” verwenden:

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

Nachdem die Frage etwas präzisiert wurde, wurde nicht nur das Unterdrücken von Nullen gefragt, sondern auch die Begrenzung der Ausgabe auf drei Nachkommastellen. Ich denke, das geht nicht allein mit sprintf-Formatzeichenfolgen. Wie Pax Diablo betonte, wäre eine String-Manipulation erforderlich.

Ich mag die Antwort von R. leicht abgeändert:

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

‘1000’ bestimmt die Genauigkeit.

Power auf die 0,5 Rundung.

BEARBEITEN

Ok, diese Antwort wurde ein paar Mal bearbeitet und ich habe den Überblick verloren, was ich vor ein paar Jahren gedacht habe (und ursprünglich hat es nicht alle Kriterien erfüllt). Hier ist also eine neue Version (die alle Kriterien erfüllt und negative Zahlen korrekt behandelt):

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);

Und die Testfälle:

#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;
}

Und die Ausgabe der Tests:

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

Jetzt sind alle Kriterien erfüllt:

• Die maximale Anzahl der Dezimalstellen hinter der Null ist festgelegt
• Nachgestellte Nullen werden entfernt
• es macht es mathematisch richtig (richtig?)
• funktioniert (jetzt) ​​auch, wenn die erste Dezimalstelle Null ist

Leider ist diese Antwort ein Zweizeiler, da sprintf gibt den String nicht zurück.

Warum nicht einfach so?

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

Ich suche die Zeichenfolge (beginnend ganz rechts) nach dem ersten Zeichen im Bereich 1 zu 9 (ASCII-Wert 49–57) dann null (einstellen 0) jedes Zeichen rechts davon – siehe unten:

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;
    }
}

Was ist mit so etwas (kann Rundungsfehler und Probleme mit negativen Werten haben, die debuggt werden müssen, als Übung für den Leser):

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

Es ist leicht programmatisch, aber zumindest lässt es Sie keine Zeichenfolgen manipulieren.

Einige der hoch bewerteten Lösungen schlagen vor %g Konvertierungsbezeichner von printf. Das ist falsch, weil es Fälle gibt, in denen %g erzeugt wissenschaftliche Notation. Andere Lösungen verwenden Mathematik, um die gewünschte Anzahl von Dezimalstellen zu drucken.

Ich denke, die einfachste Lösung ist die Verwendung sprintf mit dem %f Konvertierungsspezifizierer und um nachgestellte Nullen und möglicherweise ein Dezimalkomma manuell aus dem Ergebnis zu entfernen. Hier ist eine C99-Lösung:

#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;
}

Beachten Sie, dass die für Ziffern und das Dezimaltrennzeichen verwendeten Zeichen vom aktuellen Gebietsschema abhängen. Der obige Code geht von einem Gebietsschema in C oder US-Englisch aus.