避免 printf()中的后跟零

小开

要去掉后面的零，应该使用“% g”格式:

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

在这个问题被澄清了一点，抑制零不是唯一的问题，但限制输出到小数点后三位也是必需的。我认为只使用 sprintf 格式字符串是做不到这一点的。正如恶魔和平指出的，需要进行字符串操作。

小开

最佳答案

这不能用普通的 printf格式说明符来完成，最接近的方法是:

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

但是“ .6”是总数的数字宽度，所以

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

打破它。

可以所做的就是将 sprintf("%.20g")的数字转换为一个字符串缓冲区，然后操作该字符串使其只包含超过小数点的 N 个字符。

假设您的数字在变量 num 中，下面的函数将删除除了第一个 N小数以外的所有小数，然后去掉后面的零(如果它们都是零，则去掉小数点)。

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

(或者在 nDecimals的末尾调用 morphNumericString，但是，在这种情况下，我可能只是将这两个函数合并为一个函数) ，结果是:

  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

小开

下面是我第一次尝试的答案:

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

已知错误: 根据格式可能出现的缓冲区溢出。如果除了可能发生的错误结果外，还有其他原因。

小开

上述情况略有变化:

消除案例周期(10000.0)。
处理完第一节课后的休息时间。

这里的代码:

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

它仍然有溢出的可能，所以要小心;

小开

这样的情况怎么样(可能有舍入错误和负值问题需要调试，留给读者作为练习) :

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

它稍微有点程序化，但至少不会让您执行任何字符串操作。

小开

我喜欢 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

现在，所有的标准都满足了:

零后面的小数的最大数是固定的
后面的零被删除
它在数学上是正确的(对吗?)
也适用于第一个小数为零的情况

不幸的是，这个答案是一个两行程序，因为 sprintf不返回字符串。

小开

一个简单的解决方案，但它完成了工作，分配了一个已知的长度和精度，并避免了指数格式(当您使用% 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);
}

添加或删除“ elses”，如果你想最多2个小数; 4个小数; 等等。

例如，如果你想要两个小数:

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

小开

我搜索字符串(从最右边开始)在 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;
}
}

小开

由于 f 前面的“ .3”，代码四舍五入到小数点后三位

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

因此，如果你把第二行四舍五入到小数点后两位，你应该把它改成这样:

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;


}

小开

为什么不这么做呢？

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

小开

我在一些解决方案中发现了问题。我是根据上面的答案做出这个结论的。看起来对我有用。

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。这种说法是错误的，因为在某些情况下，ABc0会产生科学记数法。其他解决方案使用数学打印所需的小数位数。

我认为最简单的解决方案是使用 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 或美国英语语言环境。

小开

我觉得你应该用 printf("%.8g",value);

如果您使用 "%.6g"，您将不会得到所需的输出为一些数字，如.32.230210，它应该打印 32.23021，但它打印 32.2302

小开

遇到同样的问题，双精度是15位小数，浮点精度是6位小数，所以我写了2个函数分别为他们

#include <stdio.h>
#include <math.h>
#include <string>
#include <string.h>


std::string doublecompactstring(double d)
{
char buf[128] = {0};
if (isnan(d))
return "NAN";
sprintf(buf, "%.15f", d);
// try to remove the trailing zeros
size_t ccLen = strlen(buf);
for(int i=(int)(ccLen -1);i>=0;i--)
{
if (buf[i] == '0')
buf[i] = '\0';
else
break;
}


return buf;
}


std::string floatcompactstring(float d)
{
char buf[128] = {0};
if (isnan(d))
return "NAN";
sprintf(buf, "%.6f", d);
// try to remove the trailing zeros
size_t ccLen = strlen(buf);
for(int i=(int)(ccLen -1);i>=0;i--)
{
if (buf[i] == '0')
buf[i] = '\0';
else
break;
}


return buf;
}


int main(int argc, const char* argv[])
{
double a = 0.000000000000001;
float  b = 0.000001f;


printf("a: %s\n", doublecompactstring(a).c_str());
printf("b: %s\n", floatcompactstring(b).c_str());
return 0;
}

输出是

a: 0.000000000000001
b: 0.000001

小开

我需要这个 PaxDiablo 的第一个回答就能解决问题。但是我不需要截断和下面的版本可能稍微快一点？开始搜索字符串末尾(EOS)后的“ .”，只有一个 EOS 的位置。

//https://stackoverflow.com/questions/277772/avoid-trailing-zeroes-in-printf
//adapted from paxdiablo (removed truncating)
char StringForDouble[50];
char *PointerInString;
void PrintDouble (double number) {
sprintf(StringForDouble,"%.10f",number); // convert number to string
PointerInString=strchr(&StringForDouble[0],'.'); // find decimal point, if any
if(PointerInString!=NULL) {
PointerInString=strchr(&PointerInString[0],'\0'); // find end of string
do{
PointerInString--;
} while(PointerInString[0]=='0'); // remove trailing zeros
if (PointerInString[0]=='.') { // if all decimals were zeros, remove "."
PointerInString[0]='\0';
} else {
PointerInString[1]='\0'; //otherwise put EOS after the first non zero char
}
}
printf("%s",&StringForDouble[0]);
}

小开

我的想法是计算不会导致给定双精度值后跟零的需要精度，并将其传递给 printf ()中的 "%1.*f"格式。这甚至可以用一句话来表达:

int main() {
double r=1234.56789;
int precision=3;
printf(L"%1.*f", prec(r, precision), r);
}


int prec(const double& r, int precision)
{
double rPos = (r < 0)? -r : r;
double nkd = fmod(rPos, 1.0); // 0..0.99999999
int i, ex10 = 1;
for (i = 0; i < precision; ++i)
ex10 *= 10;
int nki = (int)(nkd * ex10 + 0.5);


// "Eliminate" trailing zeroes
int requiredPrecision = precision;
for (; requiredPrecision && !(nki % 10); )  {
--requiredPrecision;
nki /= 10;
}
return requiredPrecision;
}

这是另一个 %g解决方案。您应该始终提供一个“足够宽”的格式精度(默认值只有6) ，并且四舍五入。我认为这是一个不错的方法:

double round(const double &value, const double& rounding)  {
return rounding!=0 ? floor(value/rounding + 0.5)*rounding : value;
}


printf("%.12g" round(val, 0.001)); // prints up to 3 relevant digits