Namespaces
Variants

std:: isgreater

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)
isgreater
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Definido en el encabezado <cmath>
(1)
bool isgreater ( float x, float y ) ;

bool isgreater ( double x, double y ) ;

bool isgreater ( long double x, long double y ) ;
(desde C++11)
(hasta C++23)
constexpr bool isgreater ( /* floating-point-type */ x,
/* floating-point-type */ y ) ;
(desde C++23)
Definido en el encabezado <cmath>
template < class Arithmetic1, class Arithmetic2 >
bool isgreater ( Arithmetic1 x, Arithmetic2 y ) ;
(A) (desde C++11)
(constexpr desde C++23)
1) Determina si el número de punto flotante x es mayor que el número de punto flotante y , sin activar excepciones de punto flotante. La biblioteca proporciona sobrecargas para todos los tipos de punto flotante sin calificador cv como tipo de los parámetros x y y . (since C++23)
A) Se proporcionan sobrecargas adicionales para todas las demás combinaciones de tipos aritméticos.

Contenidos

Parámetros

x, y - valores de punto flotante o enteros

Valor de retorno

true si x > y , false en caso contrario.

Notas

El operator > incorporado para números de punto flotante puede establecer FE_INVALID si uno o ambos argumentos es NaN. Esta función es una versión "silenciosa" de operator > .

Las sobrecargas adicionales no están obligadas a ser proporcionadas exactamente como (A) . Solo necesitan ser suficientes para garantizar que para su primer argumento num1 y segundo argumento num2 :

  • Si num1 o num2 tiene tipo long double , entonces std :: isgreater ( num1, num2 ) tiene el mismo efecto que std :: isgreater ( static_cast < long double > ( num1 ) ,
    static_cast < long double > ( num2 ) )     .
  • En caso contrario, si num1 y/o num2 tiene tipo double o un tipo entero, entonces std :: isgreater ( num1, num2 ) tiene el mismo efecto que std :: isgreater ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • En caso contrario, si num1 o num2 tiene tipo float , entonces std :: isgreater ( num1, num2 ) tiene el mismo efecto que std :: isgreater ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(hasta C++23)

Si num1 y num2 tienen tipos aritméticos, entonces std :: isgreater ( num1, num2 ) tiene el mismo efecto que std :: isgreater ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , donde /*common-floating-point-type*/ es el tipo de punto flotante con el mayor rango de conversión de punto flotante y mayor subrango de conversión de punto flotante entre los tipos de num1 y num2 , los argumentos de tipo entero se consideran con el mismo rango de conversión de punto flotante que double .

Si no existe tal tipo de punto flotante con el mayor rango y subrango, entonces la resolución de sobrecarga no resulta en un candidato utilizable de las sobrecargas proporcionadas.

(desde C++23)

Véase también

objeto función que implementa x > y
(plantilla de clase)
(C++11)
verifica si el primer argumento de punto flotante es menor que el segundo
(función)
Documentación C para isgreater