printf（）で後続ゼロを回避する

printf（）ファミリーの関数のフォーマット指定子につまずきます。私が欲しいのは、小数点の後に指定された最大桁数のdouble（またはfloat）を印刷できるようにすることです。私が使用する場合：

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

私は得る

359.013
359.010

希望の代わりに

359.013
359.01

誰かが私を助けてくれますか？

これは、通常のprintfフォーマット指定子では実行できません。あなたが得ることができる最も近いものは：

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

「.6」は合計の数値幅なので、

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

それを壊します。

あなたができることはsprintf("%.20g")、文字列バッファへの数に対してそれから文字列を操作して小数点を過ぎたN文字だけを持つようにすることです。

数値が変数numにあるとすると、次の関数は最初のN10進数を除いてすべて削除し、後続のゼロ（およびそれらがすべてゼロの場合は小数点）を取り除きます。

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

あなたは（ターンでしょう切り捨て態様に満足していない場合0.12399に0.123それを丸めるのではなく0.124）、あなたは実際にすでににより提供される丸め機能を使用することができますprintf。事前に数値を分析して幅を動的に作成し、それらを使用して数値を文字列に変換するだけです。

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

nDecimals()この場合のポイントは、フィールド幅を正しく計算し、それに基づいてフォーマット文字列を使用して数値をフォーマットすることです。テストハーネスmain()は、この動作を示しています。

  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

正しく丸められた値を取得したら、次のように変更するだけで、再びそれに渡してmorphNumericString()後続ゼロを削除できます。

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

に：

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

（またはmorphNumericString最後に呼び出しますnDecimalsが、その場合、おそらく2つを1つの関数に結合するでしょう）、そしてあなたは次のようになります：

  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

末尾のゼロを取り除くには、「％g」形式を使用する必要があります。

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

質問が少し明確になった後、ゼロを抑制することだけが求められたわけではありませんが、出力を小数点以下3桁に制限することも必要でした。これは、sprintf形式の文字列だけでは実現できないと思います。以下のようパックスディアブロは指摘し、文字列操作が必要とされるであろう。

私はRの答えが好きです。

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

「1000」は精度を決定します。

0.5丸めの電力。

編集

わかりました。この回答は数回編集され、数年前に考えていたことがわからなくなりました（元々はすべての基準を満たしていませんでした）。だからここに新しいバージョンがあります（すべての基準を満たし、負の数を正しく処理します）：

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

そしてテストケース：

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

そしてテストの出力：

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

これで、すべての基準が満たされました。

• ゼロの後ろの小数点以下の最大数は固定されています
• 末尾のゼロは削除されます
• それは数学的に正しい（そうですか？）
• （現在）最初の10進数がゼロの場合にも機能する

残念ながら、この回答はsprintf文字列を返さないので2行です。

（一番右から）文字列を検索し1て9（ASCII値49- 57）までの範囲の最初の文字を検索し、次にその右側の各文字nullを（に設定）します- 0以下を参照してください：

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

このようなものについてはどうですか（丸め誤差と、デバッグが必要な負の値の問題がある可能性があります。読者の練習問題として残しておいてください）。

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

わずかにプログラムによるものですが、少なくとも文字列の操作はできません。

簡単な解決策ですが、仕事は完了し、既知の長さと精度が割り当てられ、指数形式になる可能性が回避されます（これは％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);
}

最大2桁の小数が必要な場合は、「elses」を追加または削除します。小数点以下4桁。等

たとえば、小数点以下2桁が必要な場合：

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

フィールドを揃えるために最小幅を指定したい場合は、必要に応じてインクリメントします。たとえば、次のようになります。

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

これを、フィールドの希望の幅を渡す関数に変換することもできます。

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

投稿されたソリューションの一部に問題が見つかりました。これを上記の回答に基づいてまとめました。それは私のために働くようです。

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

投票数の多いソリューションのいくつかは、の%g変換指定子を示唆していますprintf。%g科学的表記を生成する場合があるため、これは誤りです。他のソリューションでは、数学を使用して、必要な10進数を印刷します。

最も簡単な解決策はsprintf、%f変換指定子を使用して、結果から末尾のゼロとおそらく小数点を手動で削除することだと思います。これが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;
}

数字に使用される文字と小数点記号は、現在のロケールに依存することに注意してください。上記のコードは、Cまたは米国英語ロケールを想定しています。

これが私の最初の答えです。

ボイド
xprintfloat（char * format、float f）
{
  char s [50];
  char * p;

  sprintf（s、format、f）;
  for（p = s; * p; ++ p）
    if（ '。' == * p）{
      while（* ++ p）;
      while（ '0' == *-p）* p = '\ 0';
    }
  printf（ "％s"、s）;
}

既知のバグ：フォーマットによってはバッファオーバーフローの可能性があります。「。」の場合 ％f以外の理由で存在しています。間違った結果が発生する可能性があります。

なぜこれをしないのですか？

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

上記のわずかなバリエーション：

1. ケースの期間を排除します（10000.0）。
2. 最初の期間が処理された後に中断します。

ここにコード：

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

まだオーバーフローの可能性があるため、注意してください; P

私はあなたが使うべきだと言います printf("%.8g",value);

あなたが使用している場合"%.6g"、それは印刷する必要がありlike.32.230210あなたには、いくつかの数字のために所望の出力を得ることはありません32.23021が、それは印刷します32.2302

fの前の「.3」により、コードは小数点以下3桁に丸められます。

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

したがって、2行目を小数点以下2桁に丸める場合は、次のように変更する必要があります。

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

そのコードはあなたが望む結果を出力します：

359.013
359.01

*これは、すでに別の行に印刷していることを前提としています。そうでない場合、次のようにすると、同じ行に印刷できなくなります。

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

次のプログラムのソースコードは、この答えの私のテストでした

#include <cstdio>

int main()
{

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

    while (true){}

    return 0;

}