Namespaces
Variants

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

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
(C++11)
(C++11)
rint lrint llrint
(C++11) (C++11) (C++11)
Floating point manipulation functions
(C++11) (C++11)
(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Definiert im Header <cmath>
Rundung auf Gleitkommatypen
(1)
float rint ( float num ) ;

double rint ( double num ) ;

long double rint ( long double num ) ;
(seit C++11)
(bis C++23)
/* floating-point-type */ rint ( /* floating-point-type */ num ) ;
(seit C++23)
float rintf ( float num ) ;
(2) (seit C++11)
long double rintl ( long double num ) ;
(3) (seit C++11)
Rundung zu long
(4)
long lrint ( float num ) ;

long lrint ( double num ) ;

long lrint ( long double num ) ;
(seit C++11)
(bis C++23)
long lrint ( /* Gleitkommatyp */ num ) ;
(seit C++23)
long lrintf ( float num ) ;
(5) (seit C++11)
long lrintl ( long double num ) ;
(6) (seit C++11)
Rundung zu long long
(7)
long long llrint ( float num ) ;

long long llrint ( double num ) ;

long long llrint ( long double num ) ;
(seit C++11)
(bis C++23)
long long llrint ( /* floating-point-type */ num ) ;
(seit C++23)
long long llrintf ( float num ) ;
(8) (seit C++11)
long long llrintl ( long double num ) ;
(9) (seit C++11)
Definiert im Header <cmath>
template < class Integer >
double rint ( Integer num ) ;
(A) (seit C++11)
template < class Integer >
long lrint ( Integer num ) ;
(B) (seit C++11)
template < class Integer >
long long llrint ( Integer num ) ;
(C) (seit C++11)
1-3) Rundet das Fließkomma-Argument num auf einen ganzzahligen Wert (im Fließkommaformat), unter Verwendung des aktuellen Rundungsmodus . Die Bibliothek bietet Überladungen von std::rint für alle cv-unqualifizierten Fließkommatypen als Typ des Parameters num an. (seit C++23)
4-9) Rundet das Fließkomma-Argument num auf einen ganzzahligen Wert, unter Verwendung des aktuellen Rundungsmodus . Die Bibliothek bietet Überladungen von std::lrint und std::llrint für alle cv-unqualifizierten Fließkommatypen als Typ des Parameters num . (since C++23)
A-C) Zusätzliche Überladungen werden für alle Ganzzahltypen bereitgestellt, die als double behandelt werden.

Inhaltsverzeichnis

Parameter

num - Gleitkomma- oder Ganzzahlwert

Rückgabewert

Wenn keine Fehler auftreten, wird der nächstgelegene ganzzahlige Wert zu num , entsprechend dem aktuellen Rundungsmodus , zurückgegeben.

Fehlerbehandlung

Fehler werden gemeldet, wie in math_errhandling spezifiziert.

Wenn das Ergebnis von std::lrint oder std::llrint 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::rint Funktion:
  • 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 std::lrint und std::llrint Funktionen:
  • 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

POSIX legt fest , dass alle Fälle, in denen std::lrint oder std::llrint FE_INEXACT auslösen, Domänenfehler sind.

Wie in math_errhandling spezifiziert, kann FE_INEXACT (muss aber nicht auf Nicht-IEEE-Fließkomma-Plattformen) von std::rint ausgelöst werden, wenn ein endlicher Nicht-Ganzzahl-Wert gerundet wird.

Der einzige Unterschied zwischen std::rint und std::nearbyint ist, dass std::nearbyint niemals FE_INEXACT auslöst.

Die größten darstellbaren Fließkommawerte sind exakte Ganzzahlen in allen Standard-Fließkommaformaten, daher std::rint überläuft niemals allein; jedoch kann das Ergebnis jeden Ganzzahltyp (einschließlich std::intmax_t ) überlaufen, wenn es in einer Ganzzahlvariable gespeichert wird.

Wenn der aktuelle Rundungsmodus ist:

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

  • std :: rint ( num ) hat denselben Effekt wie std :: rint ( static_cast < double > ( num ) ) .
  • std :: lrint ( num ) hat denselben Effekt wie std :: lrint ( static_cast < double > ( num ) ) .
  • std :: llrint ( num ) hat denselben Effekt wie std :: llrint ( static_cast < double > ( num ) ) .

Beispiel

Diesen Code ausführen 
#include <cfenv>
#include <climits>
#include <cmath>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::fesetround(FE_TONEAREST);
    std::cout << "Runden auf die nächste Ganzzahl (bei .5 zur nächsten geraden Zahl):\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 << "Abrunden:\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'
              << "Abrunden mit 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'
              << "Spezielle Werte:\n"
              << "  lrint(-0.0) = " << std::lrint(-0.0) << '\n'
              << std::hex << std::showbase
              << "  lrint(-Inf) = " << std::lrint(-INFINITY) << '\n';
    // Fehlerbehandlung
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "std::rint(0.1) = " << std::rint(.1) << '\n';
    if (std::fetestexcept(FE_INEXACT))
        std::cout << "  FE_INEXACT wurde ausgelöst\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 wurde ausgelöst\n";
}

Mögliche Ausgabe: 

Runden zur nächsten Ganzzahl (Halbfälle zur geraden Zahl):
  rint(+2.3) = 2
  rint(+2.5) = 2
  rint(+3.5) = 4
  rint(-2.3) = -2
  rint(-2.5) = -2
  rint(-3.5) = -4
Abrunden:
  rint(+2.3) = 2
  rint(+2.5) = 2
  rint(+3.5) = 4
  rint(-2.3) = -2
  rint(-2.5) = -2
  rint(-3.5) = -4
Abrunden mit 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
Spezielle Werte:
  lrint(-0.0) = 0
  lrint(-Inf) = 0x8000000000000000
std::rint(0.1) = 0
std::lrint(LONG_MIN-2048.0) = 0x8000000000000000
  FE_INVALID wurde ausgelöst

Siehe auch

(C++11) (C++11) (C++11)
nächstliegende Ganzzahl, die nicht größer im Betrag als der gegebene Wert ist
(Funktion)
(C++11) (C++11) (C++11)
nächstliegende Ganzzahl unter Verwendung des aktuellen Rundungsmodus
(Funktion)
(C++11) (C++11)
ermittelt oder setzt Rundungsrichtung
(Funktion)
C-Dokumentation für rint