Namespaces
Variants

    std:: fmax, std:: fmaxf, std:: fmaxl

    From de.cppreference.net
    C++
    Numerics library
    Common mathematical functions
    Nearest integer floating point operations
    (C++11)
    (C++11)
    (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>
    (1)
    float fmax ( float x, float y ) ;

    double fmax ( double x, double y ) ;

    long double fmax ( long double x, long double y ) ;
    		(bis C++23)
    constexpr /*floating-point-type*/

    fmax ( /*floating-point-type*/ x,

    /*floating-point-type*/ y ) ;
    		(seit C++23)
    float fmaxf ( float x, float y ) ;
    		(2) (seit C++11)
    (constexpr seit C++23)
    long double fmaxl ( long double x, long double y ) ;
    		(3) (seit C++11)
    (constexpr seit C++23)
    SIMD-Überladung (seit C++26)
    Definiert im Header <simd>
    template < class V0, class V1 >

    constexpr /*math-common-simd-t*/ < V0, V1 >

    fmax ( const V0 & v_x, const V1 & v_y ) ;
    		(S) (seit C++26)
    Definiert im Header <cmath>
    template < class Integer >
    double fmax ( Integer x, Integer y ) ;
    		(A) (constexpr seit C++23)
    1-3) Gibt den größeren der beiden Gleitkomma-Argumente zurück, wobei NaNs als fehlende Daten behandelt werden (zwischen einem NaN und einem numerischen Wert wird der numerische Wert gewählt). Die Bibliothek stellt Überladungen von std::fmax für alle cv-unqualifizierten Gleitkommatypen als Parametertyp bereit. (since C++23)
    S) Die SIMD-Überladung führt eine elementweise std::fmax -Operation auf v_x und v_y durch.
    (Siehe math-common-simd-t für deren Definition.)
    		(seit C++26)
    A) Zusätzliche Überladungen werden für alle Ganzzahltypen bereitgestellt, die als double behandelt werden.
    		(since C++11)

    Inhalt

    Parameter

    x, y - Gleitkomma- oder Ganzzahlwerte

    Rückgabewert

    Bei Erfolg gibt die Funktion den größeren von zwei Gleitkommawerten zurück. Der zurückgegebene Wert ist exakt und hängt nicht von Rundungsmodi ab.

    Fehlerbehandlung

    Diese Funktion unterliegt keinen der in math_errhandling spezifizierten Fehlerbedingungen.

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

    • Wenn eines der beiden Argumente NaN ist, wird der Wert des anderen Arguments zurückgegeben.
    • Nur wenn beide Argumente NaN sind, wird NaN zurückgegeben.

    Hinweise

    Diese Funktion muss nicht auf das Vorzeichen von Null reagieren, obwohl einige Implementierungen zusätzlich sicherstellen, dass wenn ein Argument + 0 und das andere - 0 ist, dann + 0 zurückgegeben wird.

    Die zusätzlichen Überladungen müssen nicht exakt wie (A) bereitgestellt werden. Sie müssen lediglich sicherstellen, dass für ihr erstes Argument num1 und zweites Argument num2 :

    • Falls num1 oder num2 den Typ long double hat, dann hat std :: fmax ( num1, num2 ) denselben Effekt wie std :: fmax ( static_cast < long double > ( num1 ) ,
      static_cast < long double > ( num2 ) )       .
    • Andernfalls, falls num1 und/oder num2 den Typ double oder einen Ganzzahltyp hat, dann hat std :: fmax ( num1, num2 ) denselben Effekt wie std :: fmax ( static_cast < double > ( num1 ) ,
      static_cast < double > ( num2 ) )       .
    • Andernfalls, falls num1 oder num2 den Typ float hat, dann hat std :: fmax ( num1, num2 ) denselben Effekt wie std :: fmax ( static_cast < float > ( num1 ) ,
      static_cast < float > ( num2 ) )       .
    		(bis C++23)

    Falls num1 und num2 arithmetische Typen haben, dann hat std :: fmax ( num1, num2 ) denselben Effekt wie std :: fmax ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
    static_cast < /*common-floating-point-type*/ > ( num2 ) )     , wobei /*common-floating-point-type*/ der Gleitkommatyp mit dem höchsten Gleitkomma-Konvertierungsrang und der höchsten Gleitkomma-Konvertierungsunterrang zwischen den Typen von num1 und num2 ist; Argumente vom Ganzzahltyp werden als mit demselben Gleitkomma-Konvertierungsrang wie double betrachtet.

    Falls kein solcher Gleitkommatyp mit dem höchsten Rang und Unterrang existiert, dann führt die Überladungsauflösung nicht zu einem verwendbaren Kandidaten aus den bereitgestellten Überladungen.

    		(seit C++23)

    Beispiel

    Diesen Code ausführen 
    #include <cmath>
#include <iostream>
int main()
{
    std::cout << "fmax(2,1)    = " << std::fmax(2, 1) << '\n'
              << "fmax(-Inf,0) = " << std::fmax(-INFINITY, 0) << '\n'
              << "fmax(NaN,-1) = " << std::fmax(NAN, -1) << '\n';
}

    Ausgabe: 

    fmax(2,1)    = 2
fmax(-Inf,0) = 0
fmax(NaN,-1) = -1

    Siehe auch

    (C++11)
    		 prüft, ob das erste Gleitkommaargument größer als das zweite ist
    (Funktion)
    (C++11)(C++11)(C++11)
    		 kleinerer von zwei Gleitkommawerten
    (Funktion)
    		gibt den größeren der gegebenen Werte zurück
    (Funktionsvorlage & Algorithmus-Funktionsobjekt)
    (C++20)
    		gibt das größte Element in einem Bereich zurück
    (Funktionsvorlage & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 gibt das kleinere und das größere von zwei Elementen zurück
    (Funktionsvorlage & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 gibt das kleinste und das größte Element in einem Bereich zurück
    (Funktionsvorlage & Algorithmus-Funktionsobjekt)
    (C++20)
    C-Dokumentation für fmax