From cppreference.com
Defined in header
Rounding to floating-point types
floatrint(floatnum);doublerint(doublenum);longdoublerint(longdoublenum); (1)(since C++11)
(until C++23)/* floating-point-type */rint(/* floating-point-type */num);(since C++23)floatrintf(floatnum); (2) (since C++11)longdoublerintl(longdoublenum); (3) (since C++11)Rounding to long
longlrint(floatnum);longlrint(doublenum);longlrint(longdoublenum); (4)(since C++11)
(until C++23)longlrint(/* floating-point-type */num);(since C++23)longlrintf(floatnum); (5) (since C++11)longlrintl(longdoublenum); (6) (since C++11)Rounding to longlong
longlongllrint(floatnum);longlongllrint(doublenum);longlongllrint(longdoublenum); (7)(since C++11)
(until C++23)longlongllrint(/* floating-point-type */num);(since C++23)longlongllrintf(floatnum); (8) (since C++11)longlongllrintl(longdoublenum); (9) (since C++11)
Defined in header
template<classInteger>doublerint(Integernum); (A) (since C++11)template<classInteger>longlrint(Integernum); (B) (since C++11)template<classInteger>longlongllrint(Integernum); (C) (since C++11)1-3) Rounds the floating-point argument num to an integer value (in floating-point format), using the
. The library provides overloads of std::rint for all cv-unqualified floating-point types as the type of the parameter num.(since C++23)
4-9) Rounds the floating-point argument num to an integer value, using the
. The library provides overloads of std::lrint and std::llrint for all cv-unqualified floating-point types as the type of the parameter num.(since C++23)
A-C) Additional overloads are provided for all integer types, which are treated as double.
Parameters
num - floating-point or integer value Return value
If no errors occur, the nearest integer value to num, according to the
, is returned.
Error handling
Errors are reported as specified in
.
If the result of std::lrint or std::llrint is outside the range representable by the return type, a domain error or a range error may occur.
If the implementation supports IEEE floating-point arithmetic (IEC 60559),
For the std::rint function:If num is ±∞, it is returned, unmodified.
If num is ±0, it is returned, unmodified.
If num is NaN, NaN is returned.
For std::lrint and std::llrint functions:If num is ±∞,
is raised and an implementation-defined value is returned.
If the result of the rounding is outside the range of the return type,
is raised and an implementation-defined value is returned.
If num is NaN,
is raised and an implementation-defined value is returned.
Notes
that all cases where std::lrint or std::llrint raise
are domain errors.
As specified in
,
may be (but isn't required to be on non-IEEE floating-point platforms) raised by std::rint when rounding a non-integer finite value.
The only difference between std::rint and
is that
never raises
.
The largest representable floating-point values are exact integers in all standard floating-point formats, so std::rint never overflows on its own; however the result may overflow any integer type (including
), when stored in an integer variable.
If the current rounding mode is:
, then std::rint is equivalent to
.
, then std::rint is equivalent to
.
, then std::rint is equivalent to
.
, then std::rint differs from
in that halfway cases are rounded to even rather than away from zero.
The additional overloads are not required to be provided exactly as (A-C). They only need to be sufficient to ensure that for their argument num of integer type:
std::rint(num) has the same effect as std::rint(static_cast<double>(num)).
std::lrint(num) has the same effect as std::lrint(static_cast<double>(num)).
std::llrint(num) has the same effect as std::llrint(static_cast<double>(num)).
Example
Run this code
#include<cfenv>#include<climits>#include<cmath>#include<iostream>// #pragma STDC FENV_ACCESS ONintmain(){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 handlingstd::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";}Possible output:
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 See also