Избегайте конечных нулей в printf()
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 десятичные дроби, затем удалите конечные нули (и десятичную точку, если все они были нулями).
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 но в этом случае я бы, вероятно, просто объединил их в одну функцию), и в итоге вы получите:
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
После того, как вопрос прояснился немного, подавление нулей - это не единственное, что было задано, но также требовалось ограничить вывод до трех десятичных знаков. Я думаю, что это невозможно сделать только с помощью строк формата sprintf. Как отметил Pax Diablo , потребуется манипулирование строками.
Мне нравится ответ Р.немного подправил:
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 не возвращает строку.
Я ищу строку (начиная с крайнего справа) для первого символа в диапазоне от 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);
}
Добавить или удалить " elses " если вы хотите максимум 2 десятичных знака; 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 и вручную удалить конечные нули и, возможно, десятичную точку из результата. Вот решение 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;
}
Обратите внимание, что символы, используемые для цифр и десятичного разделителя, зависят от текущей локали. Приведенный выше код предполагает использование языка Си или США.
Вот моя первая попытка ответа:
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);
}
Известные ошибки: возможное переполнение буфера в зависимости от формата. Если ". & Quot; присутствует по другой причине, чем% f может произойти неправильный результат.
Почему бы просто не сделать это?
double f = 359.01335;
printf("%g", round(f * 1000.0) / 1000.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
Ваш код округляется до трех десятичных разрядов из-за " .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;
}
