不要在C ++中输出尾随零

Question

If the result is an integer, do not output the decimal point.

If the result is a floating point number, do not output any trailing zeroes.

How to do it in c or c++ :

double result;
/*some operations on result */
printf("%g", result);

Is the above approach correct? I'm not getting the correct answer with in my situation.

Answer 1

you can use snprintf to print the double value into a char array, then from the end to the head, replace the '0' with '\\0', finally you get a the number without tailling zeroes.Here is my simple code.

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

void
remove_zeroes(double number, char * result, int buf_len)
{ 
    char * pos;
    int len;

    snprintf(result, buf_len, "%lf", number);
    len = strlen(result);

    pos = result + len - 1;
 #if 0
/* according to Jon Cage suggestion, removing this part */
    while(*div != '.')
        div++;
#endif
    while(*pos == '0')
        *pos-- = '\0';

    if(*pos == '.')
        *pos = '\0';

}

int
main(void)
{
    double a;
    char test[81];

    a = 10.1;

    printf("before it is %lf\n", a);
    remove_zeroes(a, test, 81);
    printf("after it is %s\n", test);

    a = 100;
    printf("before it is %lf\n", a);
    remove_zeroes(a, test, 81);
    printf("after it is %s\n", test);


    return 0;
}

and the output is

before it is 10.100000
after it is 10.1
before it is 100.000000
after it is 100

Answer 2

I prefer readable code and this will work and be easy to understand. It requires boost though.

#include <boost/algorithm/string.hpp>

std::string value = std::to_string((double)12); //yields 12.000000
boost::trim_right_if(value, boost::is_any_of("0")); //turn 12.000000 -> 12.
boost::trim_right_if(value, boost::is_any_of(".")); //turn 12. -> 12

Note that the code below will work for 12 it will not work for 120 or 0. You must trim it two steps to not remove zeros to the immediate left of the decimal point. So don't try to save a line!

std::string value = std::to_string((double)120);
boost::trim_right_if(value, boost::is_any_of("0.")); //yields 12 not 120

It was pointed out to me in the comments that 6 digit precision might not be enough. Then try this:

#include <iostream>
#include <sstream>
#include <iomanip>
#include <boost/algorithm/string.hpp>

std::stringstream sStream;
sStream << std::fixed << std::setprecision( 16 ) << (double)12; //yields 12.0000000000000000
std::string value = sStream.str();
boost::trim_right_if(value, boost::is_any_of("0")); //turn 12.000000000000000 -> 12.
boost::trim_right_if(value, boost::is_any_of(".")); //turn 12. -> 12

Answer 3

If you know the result is an integer, you could either use an integer variable or simply cast to an integer:

double result;
/*some operations on result */
printf("%d", (int)result);

[Edit] Try something like this:

#include <stdio.h>
#include <math.h>
void VariablePrecisionPrinter( double num, double precision )
{
    if( fabs(num-int(num)) < precision )
    {
        printf("%d\n", (int) num);
    }
    else
    {
        printf("%g\n", num);
    }
}

void Test(  )
{
    const double Precision = 0.001;
    VariablePrecisionPrinter( 100.001, Precision );
    VariablePrecisionPrinter( 100.00001, Precision );
    VariablePrecisionPrinter( 0.00001, Precision );
    VariablePrecisionPrinter( 0.0, Precision );
    VariablePrecisionPrinter( 0.1, Precision );
}

...which will print:

100.001
100
0
0
0.1

[Edit2]

This is a bit clunky but it does what you ask:

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

using namespace std;

void VariablePrecisionPrinter( double num )
{
    // Convert the number to a string
    const int tmpSize = 128;
    char tmp[tmpSize] = {'\0'};
    sprintf(tmp, "%lf", num);
    string truncatedNum = tmp;

    // If the conversion ends with a 0, strip the extra parts.
    size_t p2 = truncatedNum.find_last_not_of( '0' );
    if( string::npos != p2 )
    {
        truncatedNum = truncatedNum.substr( 0, p2+1 );

        // Make sure we're not left with just a decimal point at the end
        size_t decimalPos = truncatedNum.find_last_of('.');
        if( decimalPos == truncatedNum.length()-1  )
        {
            truncatedNum = truncatedNum.substr( 0, truncatedNum.length()-1 );
        }
    }

    printf( "%s\n", truncatedNum.c_str() );
}

void Test(  )
{
    const double Precision = 0.001;
    VariablePrecisionPrinter( 100.001 );
    VariablePrecisionPrinter( 100.00001 );
    VariablePrecisionPrinter( 0.00001 );
    VariablePrecisionPrinter( 0.0 );
    VariablePrecisionPrinter( 0.1 );
}

Answer 4

For the compiler result is always a double because it's declared as such. Internally it has a different memory layout than an integer.

To do properly what you want to achieve check if result is close enough to a natural number and cast it to an appropriate integer before printing.

Answer 5

string DoubleToString (double inValue)
{
   std::stringstream buildString;

   int i = 0;
   double valueWithPrecision = 0;

   do
   {
      buildString.str(std::string());
      buildString.clear();

      buildString << std::fixed << std::setprecision(i) << inValue;

      valueWithPrecision  = std::stod(buildString.str().c_str());

      i++;
   } while (valueWithPrecision  != inValue);

   return buildString.str();
}

Answer 6

Nowadays you should just insert one line for the manipulator:

cout << noshowpoint;
cout << 12.000000000000000 << endl;

Alternatively insert this manipulation just before your output (as oneliner) if its not even the default.

If you like the other way around, then showpoint is your friend.