Nearbyint

定义于头文件 <cmath> 中。

描述

使用当前的舍入模式，将浮点参数 num 舍入为浮点格式的整数值。
​库为所有 cv-unqualified 浮点类型提供了 std::nearbyint 的重载，作为参数 num 的类型  (从 C++23 开始)。

​为所有整数类型提供了额外的重载，它们被视为 double。

声明

C++23

// 1)
/* floating-point-type */ nearbyint( /* floating-point-type */ num );
// 2)
float nearbyintf( float num );
// 3)
long double nearbyintl( long double num );

附加重载

// 4)
template< class Integer >
double nearbyint ( Integer num );

C++11

// 1)
float nearbyint ( float num );
// 2)
double nearbyint ( double num );
// 3)
long double nearbyint ( long double num );
// 4)
float nearbyintf( float num );
// 5)
long double nearbyintl( long double num );

附加重载

// 6)
template< class Integer >
double nearbyint ( Integer num );

参数

​num - 浮点或整数值

返回值

根据当前的舍入模式，返回最接近 num 的整数值。

错误处理

此函数不受 math_errhandling 中指定的任何错误的影响。

如果实现支持 IEEE 浮点运算（IEC 60559）

FE_INEXACT 从不引发
如果 num 是 ±∞，则返回，不修改
如果 num 是 ±0，则返回，不修改
如果 num 是 NaN，则返回 NaN

备注

std::nearbyint 和 std::rint 之间唯一的区别是 std::nearbyint 从不引发 FE_INEXACT。

在所有标准浮点格式中，最大的可表示浮点值都是精确整数，因此 std::nearbyint 本身永远不会溢出；但是，当存储在整数变量中时，结果可能会溢出任何整数类型（包括 std::intmax_t）。

如果当前舍入模式是 FE_TONEAREST，此函数在半值情况下舍入到偶数（类似于 std::rint，但不同于 std::round）。

不需要完全按照额外的重载提供额外的重载。

它们只需要足以确保对于整数类型的参数 num，std::nearbyint(num) 具有与 std::nearbyint(static_cast<double>(num)) 相同的效果。

示例

#include <cfenv>
#include <cmath>
#include <iostream>
 
#pragma STDC FENV_ACCESS ON
 
int main()
{
    std::fesetround(FE_TONEAREST);
    std::cout 
        << "rounding to nearest: \n"

        << "nearbyint(+2.3) = " 
        << std::nearbyint(2.3) << '\n'
        << "nearbyint(+2.5) = " 
        << std::nearbyint(2.5) << '\n'
        << "nearbyint(+3.5) = " 
        << std::nearbyint(3.5) << '\n'
        << "nearbyint(-2.3) = " 
        << std::nearbyint(-2.3) << '\n'
        << "nearbyint(-2.5) = " 
        << std::nearbyint(-2.5) << '\n'
        << "nearbyint(-3.5) = " 
        << std::nearbyint(-3.5) << '\n\n';
 
    std::fesetround(FE_DOWNWARD);
    std::cout 
        << "rounding down:\n"

        << "nearbyint(+2.3) = " 
        << std::nearbyint(2.3) << '\n'
        << "nearbyint(+2.5) = " 
        << std::nearbyint(2.5) << '\n'
        << "nearbyint(+3.5) = " 
        < std::nearbyint(3.5) << '\n'
        << "nearbyint(-2.3) = " 
        << std::nearbyint(-2.3) << '\n'
        << "nearbyint(-2.5) = " 
        << std::nearbyint(-2.5) << '\n'
        << "nearbyint(-3.5) = " 
        << std::nearbyint(-3.5) << '\n';
 
    std::cout 
        << "nearbyint(-0.0) = " 
        << std::nearbyint(-0.0)  << '\n'
        << "nearbyint(-Inf) = " 
        << std::nearbyint(-INFINITY) << '\n';
}

结果

rounding to nearest: 
nearbyint(+2.3) = 2  
nearbyint(+2.5) = 2  
nearbyint(+3.5) = 4
nearbyint(-2.3) = -2  
nearbyint(-2.5) = -2  
nearbyint(-3.5) = -4

rounding down:
nearbyint(+2.3) = 2  
nearbyint(+2.5) = 2  
nearbyint(+3.5) = 3
nearbyint(-2.3) = -3  
nearbyint(-2.5) = -3  
nearbyint(-3.5) = -4
nearbyint(-0.0) = -0
nearbyint(-Inf) = -inf