std:: round, std:: roundf, std:: roundl, std:: lround, std:: lroundf, std:: lroundl, std:: llround, std:: llroundf

Parámetros

Valor de retorno

Si no ocurren errores, se devuelve el valor entero más cercano a num , redondeando los casos intermedios alejándose de cero.

Valor de retorno

num

Si ocurre un error de dominio, se devuelve un valor definido por la implementación.

Manejo de errores

Los errores se reportan como se especifica en math_errhandling .

Si el resultado de std::lround o std::llround está fuera del rango representable por el tipo de retorno, puede ocurrir un error de dominio o un error de rango.

Si la implementación soporta aritmética de punto flotante IEEE (IEC 60559),

Para la función std::round :

• El modo de redondeo actual no tiene efecto.
• Si num es ±∞, se devuelve sin modificación.
• Si num es ±0, se devuelve sin modificación.
• Si num es NaN, se devuelve NaN.

Para las funciones std::lround y std::llround :

• FE_INEXACT nunca se activa.
• El modo de redondeo actual no tiene efecto.
• Si num es ±∞, se activa FE_INVALID y se devuelve un valor definido por la implementación.
• Si el resultado del redondeo está fuera del rango del tipo de retorno, se activa FE_INVALID y se devuelve un valor definido por la implementación.
• Si num es NaN, se activa FE_INVALID y se devuelve un valor definido por la implementación.

Notas

FE_INEXACT puede ser (pero no está obligado a ser) generado por std::round al redondear un valor finito no entero.

Los valores de punto flotante más grandes representables son enteros exactos en todos los formatos estándar de punto flotante, por lo que std::round nunca desborda por sí mismo; sin embargo, el resultado puede desbordar cualquier tipo entero (incluyendo std::intmax_t ), cuando se almacena en una variable entera.

POSIX especifica que todos los casos donde std::lround o std::llround generan FE_INEXACT son errores de dominio.

La versión double de std::round se comporta como si estuviera implementada de la siguiente manera:

#include <cfenv>
#include <cmath>
#pragma STDC FENV_ACCESS ON
double round(double x)
{
    const int save_round = std::fegetround();
    std::fesetround(FE_TOWARDZERO);
    const double result = std::rint(std::copysign(0.5 + std::fabs(x), x));
    std::fesetround(save_round);
    return result;
}

Las sobrecargas adicionales no están obligadas a ser proporcionadas exactamente como (A-C) . Solo necesitan ser suficientes para garantizar que para su argumento num de tipo entero:

• std :: round ( num ) tiene el mismo efecto que std :: round ( static_cast < double > ( num ) ) .
• std :: lround ( num ) tiene el mismo efecto que std :: lround ( static_cast < double > ( num ) ) .
• std :: llround ( num ) tiene el mismo efecto que std :: llround ( static_cast < double > ( num ) ) .

Ejemplo

#include <cassert>
#include <cfenv>
#include <cfloat>
#include <climits>
#include <cmath>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
double custom_round(double x)
{
    const int save_round = std::fegetround();
    std::fesetround(FE_TOWARDZERO);
    const double result = std::rint(std::copysign(0.5 + std::fabs(x), x));
    std::fesetround(save_round);
    return result;
}
void test_custom_round()
{
    for (const double x :
        {
            0.0, 0.3,
            0.5 - DBL_EPSILON / 2,
            0.5,
            0.5 + DBL_EPSILON / 2,
            0.7, 1.0, 2.3, 2.5, 2.7, 3.0,
            static_cast<double>(INFINITY)
        })
        assert(round(+x) == custom_round(+x) && round(-x) == custom_round(-x));
}
int main()
{
    test_custom_round();
    std::cout << std::showpos;
    // round
    std::cout << "round(+2.3) = " << std::round(2.3)
              << "  round(+2.5) = " << std::round(2.5)
              << "  round(+2.7) = " << std::round(2.7) << '\n'
              << "round(-2.3) = " << std::round(-2.3)
              << "  round(-2.5) = " << std::round(-2.5)
              << "  round(-2.7) = " << std::round(-2.7) << '\n';
    std::cout << "round(-0.0) = " << std::round(-0.0)  << '\n'
              << "round(-Inf) = " << std::round(-INFINITY) << '\n';
    // lround
    std::cout << "lround(+2.3) = " << std::lround(2.3)
              << "  lround(+2.5) = " << std::lround(2.5)
              << "  lround(+2.7) = " << std::lround(2.7) << '\n'
              << "lround(-2.3) = " << std::lround(-2.3)
              << "  lround(-2.5) = " << std::lround(-2.5)
              << "  lround(-2.7) = " << std::lround(-2.7) << '\n';
    std::cout << "lround(-0.0) = " << std::lround(-0.0)  << '\n'
              << "lround(-Inf) = " << std::lround(-INFINITY) << '\n';
    // manejo de errores
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "std::lround(LONG_MAX+1.5) = "
              << std::lround(LONG_MAX + 1.5) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    Se generó FE_INVALID\n";
}

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) = -9223372036854775808
std::lround(LONG_MAX+1.5) = -9223372036854775808
    FE_INVALID fue activada

Véase también