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

Parameter

Rückgabewert

Wenn keine Fehler auftreten, wird der nächstgelegene ganzzahlige Wert zu num zurückgegeben, wobei halbe Fälle von null weg gerundet werden.

Rückgabewert

num

Wenn ein Domänenfehler auftritt, wird ein implementierungsdefinierter Wert zurückgegeben.

Fehlerbehandlung

Fehler werden gemeldet, wie in math_errhandling spezifiziert.

Wenn das Ergebnis von std::lround oder std::llround außerhalb des durch den Rückgabetyp darstellbaren Bereichs liegt, kann ein Domänenfehler oder ein Bereichsfehler auftreten.

Wenn die Implementierung IEEE-Gleitkommaarithmetik (IEC 60559) unterstützt,

Für die std::round -Funktion:

• Der aktuelle Rundungsmodus hat keine Auswirkung.
• Wenn num ±∞ ist, wird es unverändert zurückgegeben.
• Wenn num ±0 ist, wird es unverändert zurückgegeben.
• Wenn num NaN ist, wird NaN zurückgegeben.

Für die Funktionen std::lround und std::llround :

• FE_INEXACT wird niemals ausgelöst.
• Der aktuelle Rundungsmodus hat keine Auswirkung.
• Wenn num ±∞ ist, wird FE_INVALID ausgelöst und ein implementierungsdefinierter Wert zurückgegeben.
• Wenn das Ergebnis der Rundung außerhalb des Wertebereichs des Rückgabetyps liegt, wird FE_INVALID ausgelöst und ein implementierungsdefinierter Wert zurückgegeben.
• Wenn num NaN ist, wird FE_INVALID ausgelöst und ein implementierungsdefinierter Wert zurückgegeben.

Hinweise

FE_INEXACT kann (muss aber nicht) von std::round ausgelöst werden, wenn ein endlicher Nicht-Ganzzahl-Wert gerundet wird.

Die größten darstellbaren Gleitkommawerte sind exakte Ganzzahlen in allen Standard-Gleitkommaformaten, daher std::round führt niemals alleine zu einem Überlauf; jedoch kann das Ergebnis jeden Ganzzahltyp (einschließlich std::intmax_t ) überlaufen, wenn es in einer Ganzzahlvariable gespeichert wird.

POSIX spezifiziert dass alle Fälle, in denen std::lround oder std::llround FE_INEXACT auslösen, Domänenfehler sind.

Die double -Version von std::round verhält sich, als wäre sie wie folgt implementiert:

#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;
}

Die zusätzlichen Überladungen müssen nicht exakt als (A-C) bereitgestellt werden. Sie müssen lediglich ausreichen, um sicherzustellen, dass für ihr Argument num vom Ganzzahltyp:

• std :: round ( num ) hat denselben Effekt wie std :: round ( static_cast < double > ( num ) ) .
• std :: lround ( num ) hat denselben Effekt wie std :: lround ( static_cast < double > ( num ) ) .
• std :: llround ( num ) hat denselben Effekt wie std :: llround ( static_cast < double > ( num ) ) .

Beispiel

#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;
    // runden
    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';
    // Fehlerbehandlung
    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 << "    FE_INVALID wurde ausgelöst\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 wurde ausgelöst

Siehe auch