c++如何将double类型四舍五入保留两位小数，要精确的保留

c++

最近才发现printf("%.2f",a)并不能保证总数准确的保留两位小数
例如double a=37.975，则输出37.97，而不是37.98

请问怎么才能实现四舍五入的输出，谢谢

20 个解决方案

#1

a+0.0049

#2

a+0.005

#3

不能完全保证
不过流输出，大致是四舍五入的

#4

//Round(1.234,2) = 1.23
//Round(1.234,0) = 1.0
//Round(123.4,-1) = 120.0
double Round(double dVal, short iPlaces) {
    double dRetval;
    double dMod = 0.0000001;
    if (dVal<0.0) dMod=-0.0000001;
    dRetval=dVal;
    dRetval+=(5.0/pow(10.0,iPlaces+1.0));
    dRetval*=pow(10.0,iPlaces);
    dRetval=floor(dRetval+dMod);
    dRetval/=pow(10.0,iPlaces);
    return(dRetval);
}

double round(double dVal, short iPlaces) //iPlaces>=0
{
    unsigned char s[20];
    double dRetval;

    sprintf(s,"%.*lf",iPlaces,dVal);
    sscanf(s,"%lf",&dRetval);
    return (dRetval);
}

#5

what's your compiler?

#6

使用round函数试试


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

int main(void) {
    printf("%.2f",round(37.975*1e3)/1e3);
    return 0;
}

#7

浮点数就不要指望精确，用大数库试试。

#8

转换成字符，自己判断，然后再返回值

#9

http://bbs.csdn.net/topics/390676437

#10

引用 4 楼 zhao4zhong1 的回复:

//Round(1.234,2) = 1.23
//Round(1.234,0) = 1.0
//Round(123.4,-1) = 120.0
double Round(double dVal, short iPlaces) {
    double dRetval;
    double dMod = 0.0000001;
    if (dVal<0.0) dMod=-0.0000001;
    dRetval=dVal;
    dRetval+=(5.0/pow(10.0,iPlaces+1.0));
    dRetval*=pow(10.0,iPlaces);
    dRetval=floor(dRetval+dMod);
    dRetval/=pow(10.0,iPlaces);
    return(dRetval);
}

double round(double dVal, short iPlaces) //iPlaces>=0
{
    unsigned char s[20];
    double dRetval;

    sprintf(s,"%.*lf",iPlaces,dVal);
    sscanf(s,"%lf",&dRetval);
    return (dRetval);
}

老师，你这个原理就是+0.005呗？
我还想问下，我include<math.h>,咋说，round是未声明的标识符，前提是没自己写round函数。
老师，我还有个问题，我#include<stdio>总是报错，无法打开源文件，#include<stdio.h>就解决了，想了解下原因
谢谢老师啦

#11

大嘴的代码写得太拙劣... c++如何将double类型四舍五入保留两位小数，要精确的保留

来一个好一点的：


double RoundTo(double N, int Digit)
{
  if ((Digit < -37) || (Digit > 37))
    return N;
  double Factor = pow(10.0, Digit);
  if (N < 0)
    return floor(N / Factor - 0.5) * Factor;
  else
    return floor(N / Factor + 0.5) * Factor;
}

用法和大嘴的代码一样。

#12

Round的原理是+0.5
round不是。

#13

引用 10 楼 huhuint 的回复:

Quote: 引用 4 楼 zhao4zhong1 的回复:

//Round(1.234,2) = 1.23
//Round(1.234,0) = 1.0
//Round(123.4,-1) = 120.0
double Round(double dVal, short iPlaces) {
    double dRetval;
    double dMod = 0.0000001;
    if (dVal<0.0) dMod=-0.0000001;
    dRetval=dVal;
    dRetval+=(5.0/pow(10.0,iPlaces+1.0));
    dRetval*=pow(10.0,iPlaces);
    dRetval=floor(dRetval+dMod);
    dRetval/=pow(10.0,iPlaces);
    return(dRetval);
}

double round(double dVal, short iPlaces) //iPlaces>=0
{
    unsigned char s[20];
    double dRetval;

    sprintf(s,"%.*lf",iPlaces,dVal);
    sscanf(s,"%lf",&dRetval);
    return (dRetval);
}

cstdio C++库文件风格
stdio.h 这是C原本的样式

#14

#include <stdio.h>
#include <math.h>
double round(double r)
{
    return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
}
int main(void)
{
    printf("%.2f",round(37.975*1e3)/1e3);
    return 0;
}

#15

#include <stdio.h>
#include <math.h>
double round(double r)
{
    return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
}
int main(void) 
{
    printf("%.2f",round(37.975*1e3)/1e3);
    return 0;
}

                                                            2.1             2.6              -2.1              -2.6
floor : 不大于自变量的最大整数             2                2                  -3                  -3
ceil   :不小于自变量的最大整数              3                3                  -2                  -2
round:四舍五入到最邻近的整数             2                3                  -2                  -3

floor(),ceil() 需包含头文件<math.h>

C++中没有直接的round函数需自己建立
double round(double r)
{
    return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
}

#16

引用 15 楼 Baoge_leopard 的回复:

#include <stdio.h>
#include <math.h>
double round(double r)
{
    return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
}
int main(void) 
{
    printf("%.2f",round(37.975*1e3)/1e3);
    return 0;
}
                                                            2.1             2.6              -2.1              -2.6
floor : 不大于自变量的最大整数             2                2                  -3                  -3
ceil   :不小于自变量的最大整数              3                3                  -2                  -2
round:四舍五入到最邻近的整数             2                3                  -2                  -3

floor(),ceil() 需包含头文件<math.h>

C++中没有直接的round函数需自己建立
double round(double r)
{
    return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
}

不应该自带round函数吗？可以查到啊？
那自带的round函数怎么用？

#17

引用 13 楼 jianwen0529 的回复:

Quote: 引用 10 楼 huhuint 的回复:
Quote: 引用 4 楼 zhao4zhong1 的回复:
//Round(1.234,2) = 1.23
//Round(1.234,0) = 1.0
//Round(123.4,-1) = 120.0
double Round(double dVal, short iPlaces) {
    double dRetval;
    double dMod = 0.0000001;
    if (dVal<0.0) dMod=-0.0000001;
    dRetval=dVal;
    dRetval+=(5.0/pow(10.0,iPlaces+1.0));
    dRetval*=pow(10.0,iPlaces);
    dRetval=floor(dRetval+dMod);
    dRetval/=pow(10.0,iPlaces);
    return(dRetval);
}

double round(double dVal, short iPlaces) //iPlaces>=0
{
    unsigned char s[20];
    double dRetval;

    sprintf(s,"%.*lf",iPlaces,dVal);
    sscanf(s,"%lf",&dRetval);
    return (dRetval);
}
老师，你这个原理就是+0.005呗？
我还想问下，我include<math.h>,咋说，round是未声明的标识符，前提是没自己写round函数。
老师，我还有个问题，我#include<stdio>总是报错，无法打开源文件，#include<stdio.h>就解决了，想了解下原因
谢谢老师啦
cstdio C++库文件风格
stdio.h 这是C原本的样式

哦了解了

#18

引用 16 楼 huhuint 的回复:

Quote: 引用 15 楼 Baoge_leopard 的回复:
#include <stdio.h>
#include <math.h>
double round(double r)
{
    return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
}
int main(void) 
{
    printf("%.2f",round(37.975*1e3)/1e3);
    return 0;
}
                                                            2.1             2.6              -2.1              -2.6
floor : 不大于自变量的最大整数             2                2                  -3                  -3
ceil   :不小于自变量的最大整数              3                3                  -2                  -2
round:四舍五入到最邻近的整数             2                3                  -2                  -3

floor(),ceil() 需包含头文件<math.h>

C++中没有直接的round函数需自己建立
double round(double r)
{
    return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
}
不应该自带round函数吗？可以查到啊？
那自带的round函数怎么用？

我也没查到，你在哪找到的

#19

引用 18 楼 Baoge_leopard 的回复:

Quote: 引用 16 楼 huhuint 的回复:
Quote: 引用 15 楼 Baoge_leopard 的回复:
#include <stdio.h>
#include <math.h>
double round(double r)
{
    return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
}
int main(void) 
{
    printf("%.2f",round(37.975*1e3)/1e3);
    return 0;
}
                                                            2.1             2.6              -2.1              -2.6
floor : 不大于自变量的最大整数             2                2                  -3                  -3
ceil   :不小于自变量的最大整数              3                3                  -2                  -2
round:四舍五入到最邻近的整数             2                3                  -2                  -3

floor(),ceil() 需包含头文件<math.h>

C++中没有直接的round函数需自己建立
double round(double r)
{
    return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
}
不应该自带round函数吗？可以查到啊？
那自带的round函数怎么用？
我也没查到，你在哪找到的

百度，嘿嘿

#20

#include <iostream>
#include <sstream>
#include <iomanip>
using namespace std;

double round(double number, unsigned int bits) {
    stringstream ss;
    ss << fixed << setprecision(bits) << number;
    ss >> number;
    return number;
}

int main() {
    double number = 3.1415926535897932;
    cout << fixed << showpoint << setprecision(15);
    cout << "一开始number = " << number << endl;

    for (int i = 0; i < 15; ++i) {
        cout << "number保留" << i << "位小数后为: "
            << round(number, i) << endl;
    }

    return 0;
}

#21

js中Double类型数据保留两位小数（非四舍五入）

#1