printf ()의 후행 0을 피하십시오.
https://stackoverflow.com/questions/277772
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
Printf () 함수 제품군의 형식 지정자에 대해 계속 걸려 넘어집니다. 내가 원하는 것은 소수점 후 최대 수의 숫자로 이중 (또는 부유물)을 인쇄 할 수 있어야합니다. 내가 사용하는 경우 :
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에 있다고 가정하면 다음 함수는 첫 번째 기능을 모두 제거합니다. N 데시 말을 한 다음 후행 0을 벗겨냅니다.
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() 간단히 변경하여 후행 0을 제거하려면 :
nDecimals (str, num[i], 3);
안으로:
nDecimals (str, num[i], 3);
morphNumericString (str, 3);
(또는 전화 morphNumericString 끝에 nDecimals 그러나이 경우, 나는 아마도 두 가지를 하나의 함수로 결합 할 것입니다), 당신은 다음과 같이 끝납니다.
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
다른 팁
후행 0을 제거하려면 "%g"형식을 사용해야합니다.
float num = 1.33;
printf("%g", num); //output: 1.33
질문이 약간 명확 해지자, 제로를 억제하는 것이 유일한 것은 아니지만, 출력을 3 자리로 제한하는 것이 필요했습니다. Sprintf 형식 문자열만으로는 할 수 없다고 생각합니다. 처럼 PAX 디아블로 지적하면 문자열 조작이 필요합니다.
나는 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
이제 모든 기준이 충족됩니다.
- 0 뒤에 최대 소수점 수가 고정되어 있습니다
- 후행 0이 제거됩니다
- 수학적으로 옳습니다 (맞습니까?)
- 작동 (현재) 또한 첫 번째 소수점이 0 일 때
불행히도이 대답은 2 라이너입니다 sprintf 문자열을 반환하지 않습니다.
범위의 첫 번째 문자에 대한 문자열 (가장 오른쪽 시작)을 검색합니다. 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 과학적 표기법을 만들어 낼 것입니다. 다른 솔루션은 수학을 사용하여 원하는 소수점 숫자를 인쇄합니다.
가장 쉬운 솔루션은 사용하는 것입니다 sprintf 이랑 %f 전환 지정자 및 후행 0 및 결과에서 소수점을 수동으로 제거합니다. 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 또는 미국 영어 로케일을 가정합니다.
답에 대한 첫 번째 시도는 다음과 같습니다.
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);
}
알려진 버그 : 형식에 따라 가능한 버퍼 오버플로. 만약에 "." %f 잘못된 결과가 발생할 수있는 다른 이유가 있습니다.
왜 그렇게하지 않습니까?
double f = 359.01335;
printf("%g", round(f * 1000.0) / 1000.0);
위의 약간의 변형 :
- 케이스 기간 (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;
}
}
}
여전히 오버플로의 가능성이 있으므로 조심하십시오. P
귀하의 코드는 F 이전의 ".3"으로 인해 소수점 이하 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;
}
