Namespaces
Variants

std:: isgreaterequal

From 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)
(C++11)
isgreaterequal
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Défini dans l'en-tête <cmath>
(1)
bool isgreaterequal ( float x, float y ) ;

bool isgreaterequal ( double x, double y ) ;

bool isgreaterequal ( long double x, long double y ) ;
(depuis C++11)
(jusqu'à C++23)
constexpr bool isgreaterequal ( /* floating-point-type */ x,
/* floating-point-type */ y ) ;
(depuis C++23)
Défini dans l'en-tête <cmath>
template < class Arithmetic1, class Arithmetic2 >
bool isgreaterequal ( Arithmetic1 x, Arithmetic2 y ) ;
(A) (depuis C++11)
(constexpr depuis C++23)
1) Détermine si le nombre à virgule flottante x est supérieur ou égal au nombre à virgule flottante y , sans déclencher d'exceptions à virgule flottante. La bibliothèque fournit des surcharges pour tous les types à virgule flottante non qualifiés cv comme type des paramètres x et y . (depuis C++23)
A) Des surcharges supplémentaires sont fournies pour toutes les autres combinaisons de types arithmétiques.

Table des matières

Paramètres

x, y - valeurs à virgule flottante ou entières

Valeur de retour

true si x >= y , false sinon.

Notes

L'opérateur intégré operator >= pour les nombres à virgule flottante peut lever FE_INVALID si un ou deux des arguments est NaN. Cette fonction est une version "silencieuse" de operator >= .

Les surcharges supplémentaires ne sont pas tenues d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur premier argument num1 et second argument num2 :

  • Si num1 ou num2 a le type long double , alors std :: isgreaterequal ( num1, num2 ) a le même effet que std :: isgreaterequal ( static_cast < long double > ( num1 ) ,
    static_cast < long double > ( num2 ) )     .
  • Sinon, si num1 et/ou num2 a le type double ou un type entier, alors std :: isgreaterequal ( num1, num2 ) a le même effet que std :: isgreaterequal ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • Sinon, si num1 ou num2 a le type float , alors std :: isgreaterequal ( num1, num2 ) a le même effet que std :: isgreaterequal ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(jusqu'en C++23)

Si num1 et num2 ont des types arithmétiques, alors std :: isgreaterequal ( num1, num2 ) a le même effet que std :: isgreaterequal ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , où /*common-floating-point-type*/ est le type à virgule flottante ayant le plus grand rang de conversion en virgule flottante et la plus grande sous-catégorie de conversion en virgule flottante entre les types de num1 et num2 , les arguments de type entier sont considérés comme ayant le même rang de conversion en virgule flottante que double .

Si aucun tel type à virgule flottante avec le plus grand rang et la plus grande sous-catégorie n'existe, alors la résolution de surcharge ne résulte pas en un candidat utilisable parmi les surcharges fournies.

(depuis C++23)

Voir aussi

objet fonction implémentant x >= y
(modèle de classe)
(C++11)
vérifie si le premier argument à virgule flottante est inférieur ou égal au second
(fonction)
Documentation C pour isgreaterequal