std::rint、std::rintf、std::rintl、std::lrint、std::lrintf、std::lrintl、std::llrint、std::llrintf

定义在头文件 `<cmath>` 中
舍入到浮点类型
	(1)
float rint ( float num ); double rint ( double num ); long double rint ( long double num );			(自 C++11 起) (直到 C++23)
/* 浮点类型 / rint( / 浮点类型 */ num );			(自 C++23 起)
float rintf( float num );		(2)	(自 C++11 起)
long double rintl( long double num );		(3)	(自 C++11 起)
舍入到 long
		(4)
long lrint ( float num ); long lrint ( double num ); long lrint ( long double num );				(自 C++11 起) (直到 C++23)
long lrint ( /* 浮点类型 */ num );				(自 C++23 起)
long lrintf( float num );			(5)	(自 C++11 起)
long lrintl( long double num );			(6)	(自 C++11 起)
舍入到 long long
			(7)
long long llrint ( float num ); long long llrint ( double num ); long long llrint ( long double num );					(自 C++11 起) (直到 C++23)
long long llrint ( /* 浮点类型 */ num );					(自 C++23 起)
long long llrintf( float num );				(8)	(自 C++11 起)
long long llrintl( long double num );				(9)	(自 C++11 起)
其他重载
定义在头文件 `<cmath>` 中
template< class Integer > double rint( Integer num );				(A)	(自 C++11 起)
template< class Integer > long lrint( Integer num );				(B)	(自 C++11 起)
template< class Integer > long long llrint( Integer num );				(C)	(自 C++11 起)

1-3) 使用当前舍入模式将浮点参数num舍入到一个整数值（以浮点格式）。库为所有 cv 无限定浮点类型提供 std::rint 的重载，作为参数 num 的类型。(自 C++23 起)

4-9) 使用当前舍入模式将浮点参数num舍入到一个整数值。库为所有 cv 无限定浮点类型提供 std::lrint 和 std::llrint 的重载，作为参数 num 的类型。(自 C++23 起)

A-C) 还提供了所有整数类型的其他重载，它们被视为 double。

[编辑] 参数

num

-

浮点或整数值

[编辑] 返回值

如果沒有錯誤發生，則根據當前的舍入模式，返回最接近num的整數值。

[编辑] 错误处理

错误报告如math_errhandling中所述。

如果std::lrint或std::llrint的结果超出返回类型可表示的范围，则可能会发生域错误或范围错误。

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

对于std::rint函数

如果num为 ±∞，则直接返回。
如果num为 ±0，则直接返回。
如果num为 NaN，则返回 NaN。

对于std::lrint和std::llrint函数

如果num为 ±∞，则会引发FE_INVALID，并返回一个实现定义的值。
如果舍入结果超出返回类型的范围，则会引发FE_INVALID，并返回一个实现定义的值。
如果num为 NaN，则会引发FE_INVALID，并返回一个实现定义的值。

[编辑] 注释

POSIX 规定，所有std::lrint或std::llrint引发FE_INEXACT的情况都是域错误。

如math_errhandling中所述，FE_INEXACT可能会（但在非 IEEE 浮点平台上不一定是必须）由std::rint在舍入非整数有限值时引发。

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

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

如果当前舍入模式为

FE_DOWNWARD，则std::rint等效于std::floor。
FE_UPWARD，则std::rint等效于std::ceil。
FE_TOWARDZERO，则std::rint等效于std::trunc。
FE_TONEAREST，则std::rint与std::round不同，它将一半情况舍入为偶数，而不是远离零。

额外的重载不需要完全按照(A-C)提供。它们只需要足够多，以确保对于其整型参数num

std::rint(num)的作用与std::rint(static_cast<double>(num))相同。
std::lrint(num)的作用与std::lrint(static_cast<double>(num))相同。
std::llrint(num)的作用与std::llrint(static_cast<double>(num))相同。

[编辑] 示例

运行此代码

#include <cfenv>
#include <climits>
#include <cmath>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
 
int main()
{
    std::fesetround(FE_TONEAREST);
    std::cout << "Rounding to nearest (halfway cases to even):\n"
              << "  rint(+2.3) = " << std::rint(2.3) << '\n'
              << "  rint(+2.5) = " << std::rint(2.5) << '\n'
              << "  rint(+3.5) = " << std::rint(3.5) << '\n'
              << "  rint(-2.3) = " << std::rint(-2.3) << '\n'
              << "  rint(-2.5) = " << std::rint(-2.5) << '\n'
              << "  rint(-3.5) = " << std::rint(-3.5) << '\n';
 
    std::fesetround(FE_DOWNWARD);
    std::cout << "Rounding down:\n"
              << "  rint(+2.3) = " << std::rint(2.3) << '\n'
              << "  rint(+2.5) = " << std::rint(2.5) << '\n'
              << "  rint(+3.5) = " << std::rint(3.5) << '\n'
              << "  rint(-2.3) = " << std::rint(-2.3) << '\n'
              << "  rint(-2.5) = " << std::rint(-2.5) << '\n'
              << "  rint(-3.5) = " << std::rint(-3.5) << '\n'
              << "Rounding down with lrint:\n"
              << "  lrint(+2.3) = " << std::lrint(2.3) << '\n'
              << "  lrint(+2.5) = " << std::lrint(2.5) << '\n'
              << "  lrint(+3.5) = " << std::lrint(3.5) << '\n'
              << "  lrint(-2.3) = " << std::lrint(-2.3) << '\n'
              << "  lrint(-2.5) = " << std::lrint(-2.5) << '\n'
              << "  lrint(-3.5) = " << std::lrint(-3.5) << '\n'
              << "Special values:\n"
              << "  lrint(-0.0) = " << std::lrint(-0.0) << '\n'
              << std::hex << std::showbase
              << "  lrint(-Inf) = " << std::lrint(-INFINITY) << '\n';
 
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
 
    std::cout << "std::rint(0.1) = " << std::rint(.1) << '\n';
    if (std::fetestexcept(FE_INEXACT))
        std::cout << "  FE_INEXACT was raised\n";
 
    std::feclearexcept(FE_ALL_EXCEPT);
 
    std::cout << "std::lrint(LONG_MIN-2048.0) = "
              << std::lrint(LONG_MIN - 2048.0) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "  FE_INVALID was raised\n";
}

可能的输出

Rounding to nearest (halfway cases to even):
  rint(+2.3) = 2
  rint(+2.5) = 2
  rint(+3.5) = 4
  rint(-2.3) = -2
  rint(-2.5) = -2
  rint(-3.5) = -4
Rounding down:
  rint(+2.3) = 2
  rint(+2.5) = 2
  rint(+3.5) = 4
  rint(-2.3) = -2
  rint(-2.5) = -2
  rint(-3.5) = -4
Rounding down with lrint:
  lrint(+2.3) = 2
  lrint(+2.5) = 2
  lrint(+3.5) = 3
  lrint(-2.3) = -3
  lrint(-2.5) = -3
  lrint(-3.5) = -4
Special values:
  lrint(-0.0) = 0
  lrint(-Inf) = 0x8000000000000000
std::rint(0.1) = 0
std::lrint(LONG_MIN-2048.0) = 0x8000000000000000
  FE_INVALID was raised

[编辑] 另请参阅

trunctruncftruncl (C++11)(C++11)(C++11)	最接近给定值的非负整数 (函数) [编辑]
nearbyintnearbyintfnearbyintl (C++11)(C++11)(C++11)	使用当前舍入模式的最接近整数 (函数) [编辑]
fegetroundfesetround (C++11)(C++11)	获取或设置舍入方向 (函数) [编辑]
C 文档 for rint

编译器支持
独立和宿主
语言
标准库
标准库头文件
命名要求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用实用程序库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
执行支持库 (C++26)
技术规范
符号索引
外部库

cppreference.com

命名空间

变体

视图

操作