std::isgreater(3)

💖 std::isgreater(3) 💖

okay bestie, welcome to std::isgreater(3) from the C++ Standard Libary — yes, that’s the manual name, and this page is literally the whole vibe. 💅✨

🎀 NAME 🎀

std::isgreater - std::isgreater. that’s it, that’s the name, no cap. 💖

🌈 Synopsis 🌈

here’s the synopsis, copied exactly because code is sacred and we do not mess with it, periodt:

          Defined in header <cmath>
          bool isgreater( float x, float y );
                                                                       (since
       C++11)
          bool isgreater( double x, double y );                        (until
       C++23)

          bool isgreater( long double x, long double y );
          constexpr bool isgreater( /* floating-point-type */
          x,                                                   (1)     (since
       C++23)
                                    /* floating-point-type */
          y );
          Additional overloads
          Defined in header <cmath>
          template< class Arithmetic1, class Arithmetic2 >         (A) (since
       C++11)
          bool isgreater( Arithmetic1 x, Arithmetic2 y );
       (constexpr since C++23)

so what’s the tea? 1) is the main-character overload: it determines if the floating point number x is greater than the floating-point number y, and it does that without setting floating-point exceptions. 🫶

also, (since C++23), the library provides overloads for all cv-unqualified floating-point types as the type of the parameters x and y. ✨

(A) means additional overloads are provided for all other combinations of arithmetic types — and yes, that’s (since C++11). 💜

💅 Parameters 💅

• x, y — floating-point or integer values. that’s the whole cast, bestie. 🎀

🫶 Return value 🫶

• true if x > y, false otherwise. literally the whole plot. 🌸

🧠 Notes 🧠

okay so this is the important lore: the built-in operator> for floating-point numbers may set FE_INVALID if one or both of the arguments is NaN. 😭 this function is a "quiet" version of operator>, so it’s giving calm, collected, no-drama energy. 💅

the additional overloads are not required to be provided exactly as (A). they only need to be sufficient to ensure that for their first argument num1 and second argument num2:

• If num1 or num2 has type long double, then std::isgreater(num1, num2) has the same effect as std::isgreater(static_cast<long double>(num1), static_cast<long double>(num2)). 🔥
• Otherwise, if num1 and/or num2 has type double or an integer type, then std::isgreater(num1, num2) has the same effect as, until C++23, std::isgreater(static_cast<double>(num1), static_cast<double>(num2)). 🌈
• Otherwise, if num1 or num2 has type float, then std::isgreater(num1, num2) has the same effect as std::isgreater(static_cast<float>(num1), static_cast<float>(num2)). ⭐

If num1 and num2 have arithmetic types, then std::isgreater(num1, num2) has the same effect as std::isgreater(static_cast</* common-floating-point-type */>(num1), static_cast</* common-floating-point-type */>(num2)), where /* common-floating-point-type */ is the floating-point type with the greatest floating-point conversion rank and greatest floating-point conversion subrank between the types of num1 and num2; (since C++23) arguments of integer type are considered to have the same floating-point conversion rank as double. 🦋

If no such floating-point type with the greatest rank and subrank exists, then overload resolution does not result in a usable candidate from the overloads provided. 💀

👀 See also 👀

• greater — function object implementing x > y (class template). 👑
• isless — checks if the first floating-point argument is less than the second (C++11) (function). 🍓
• C documentation for isgreater. 🧚

mwah 💋 source/version: http://cppreference.com, date: 2024.06.10, page: std::isgreater(3). 💖