# C++最接近整数的浮点运算

Function

return

ceil

floor

trunc (C++11)

round(C++11)

lround(C++11)

llround (C++11)

1.ceil–向上取整

```/*

float       ceil(float arg);(1)
double      ceil(double arg);(2)
long double ceil(long double arg);(3)
double      ceil(Integral arg);(4)  (C++11 起)
*/
#include <cmath>
#include <iostream>
using namespace std;
int main()
{
cout << fixed
<< "ceil(+2.4) = " << ceil(+2.4) << '\n'
<< "ceil(-2.4) = " << ceil(-2.4) << '\n'
<< "ceil(-0.0) = " << ceil(-0.0) << '\n'
<< "ceil(-Inf) = " << ceil(-INFINITY) << '\n';
}```
```输出：

ceil(+2.4) = 3.000000
ceil(-2.4) = -2.000000
ceil(-0.0) = -0.000000
ceil(-Inf) = -INF```

2.floor–向下取整

```/*函数原型
float       floor( float arg );(1)
double      floor( double arg );(2)
long double floor( long double arg );(3)
double      floor( Integral arg );(4)   (C++11 起)
*/```
```#include <cmath>
#include <iostream>
using namespace std;
int main()
{
cout << fixed
<< "floor(+2.7) = " <<floor(+2.7) << '\n'
<< "floor(-2.7) = " << floor(-2.7) << '\n'
<< "floor(-0.0) = " << floor(-0.0) << '\n'
<< "floor(-Inf) = " << floor(-INFINITY) << '\n';
}

floor(+2.7) = 2.000000
floor(-2.7) = -3.000000
floor(-0.0) = -0.000000
floor(-Inf) = -inf```

3.trunc—保留整数部分

```//函数原型
float       trunc( float arg );
double      trunc( double arg );
long double trunc( long double arg );
double      trunc( Integral arg );```
```#include <cmath>
#include <iostream>
using namespace std;
int main()
{
cout << fixed
<< "trunc(+2.7) = " << trunc(+2.7) << '\n'
<< "trunc(-2.9) = " << trunc(-2.9) << '\n'
<< "trunc(-0.0) = " << strunc(-0.0) << '\n'
<< "trunc(-Inf) = " << strunc(-INFINITY) << '\n';
}```
```可能的输出：

trunc(+2.7) = 2.000000
trunc(-2.9) = -2.000000
trunc(-0.0) = -0.000000
trunc(-Inf) = -inf```

4.round,lround,llround–四舍五入 函数原型：

```float round( float arg );
double round( double arg );
long double round( long double arg );
double round( Integral arg );
long lround( float arg );
long lround( double arg );
long lround( long double arg );
long lround( Integral arg );
long long llround( float arg );
long long llround( double arg );
long long llround( long double arg );
long long llround( Integral arg );```
```#include <iostream>
#include <cmath>
using namespace std;
int main()
{
// round
cout << "round(+2.3) = " << round(2.3)
<< "  round(+2.5) = " << round(2.5)
<< "  round(+2.7) = " << round(2.7) << endl
<< "round(-2.3) = " << round(-2.3)
<< "  round(-2.5) = " << round(-2.5)
<< "  round(-2.7) = " << round(-2.7) << endl;

cout << "round(-0.0) = " << round(-0.0) << endl
<< "round(-Inf) = " << round(-INFINITY) << endl;

// lround
cout << "lround(+2.3) = " << lround(2.3)
<< "  lround(+2.5) = " << lround(2.5)
<< "  lround(+2.7) = " << lround(2.7) << endl
<< "lround(-2.3) = " << lround(-2.3)
<< "  lround(-2.5) = " << lround(-2.5)
<< "  lround(-2.7) = " << lround(-2.7) << endl;

cout << "lround(-0.0) = " << lround(-0.0) << endl
<< "lround(-Inf) = " << lround(-INFINITY) << endl;
return 0;
}```

```round(+2.3) = 2  round(+2.5) = 3  round(+2.7) = 3
round(-2.3) = -2  round(-2.5) = -3  round(-2.7) = -3
round(-0.0) = -0
round(-Inf) = -inf
lround(+2.3) = 2  lround(+2.5) = 3  lround(+2.7) = 3
lround(-2.3) = -2  lround(-2.5) = -3  lround(-2.7) = -3
lround(-0.0) = 0
lround(-Inf) = 0```

0 条评论

• ### atan和atan2反正切计算

返回值 若不出现错误，则返回 arg 在[−π/2;+π/2][−π/2;+π/2] [- π/2 ; +π/2] 弧度范围中的弧（反）正切（ arctan...

• ### HUD 1411--校庆神秘建筑(欧拉四面体体积计算)

校庆神秘建筑 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (...

• ### 测试思想-流程规范 用例优先级定义与使用规范 V1.0

对软件测试过程中的用例级别进行详细描述及标准化定义，明确不同测试阶段的测试范围，减少测试冗余投入，提高测试效率，建立测试质量基线，减少生产故障事件。

• ### 分布式事务实现原理【BAT 面试题宝库附详尽答案解析】

事务是数据库从一个稳定状态变迁到另一个稳定状态的保证，具备 ACID 这 4 个特性：

• ### 红队后渗透测试中的文件传输技巧

在红队渗透测试当中往往需要最大化利用当前的环境绕过重兵防守的系统的防火墙，IDS，IPS等报警和监控系统进行文件传输，本文列出了多种利用操作系统默认自带的工具进...

• ### [每天五分钟，备战架构师-10]数据库系统

事务是数据库系统运行的基本工作单位，相当于操作系统中的进程，事务具有ACID特性。从用户的角度来看，事务中的操作要么都做，要么都不做。

• ### 浅析spring声明式事务使用

springboot中和注解形式的是在@Transactional注解中配置的(添加注解时添加这些):

• ### MySQL基础篇3 mysql的事务隔离

MySQL 是一个支持多引擎的系统，但并不是所有的引擎都支持事务。比如 MySQL 原生的 MyISAM 引擎就不支持事务，这也是 MyISAM 被 InnoD...

• ### 闲话聊聊事务处理(中)

上面提到了multi-object事务，但是要完美的处理multi-object事务并不容易。因为我们必须要面对并发问题导致的bug，而隔离性要求数据系统...