> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Greater Than Or Equal To The `>=` (greater than or equal to) operator is a binary relational operator that evaluates the relative magnitude of two operands. It yields a `bool` value of `true` if the left-hand side (LHS) operand is strictly greater than or mathematically equivalent to the right-hand side (RHS) operand, and `false` otherwise. ```cpp theme={"dark"} lhs >= rhs ``` ## Technical Characteristics * **Return Type:** `bool` (for built-in types). * **Associativity:** Left-to-right. * **Precedence:** Level 9. It binds less tightly than arithmetic operators (`+`, `-`, `*`, `/`) and bitwise shift operators (`<<`, `>>`), but more tightly than equality operators (`==`, `!=`) and logical operators (`&&`, `||`). * **Usual Arithmetic Conversions:** When comparing built-in numeric types of different sizes or domains, the compiler applies the usual arithmetic conversions to establish a common type before evaluating. This includes integral promotions (e.g., promoting a `short` to an `int`) or floating-point conversions (e.g., converting an `int` to a `double`). ## Pointer Comparison When applied to pointers, `>=` evaluates their relative memory addresses. According to the C++ standard, relational pointer comparison is well-defined only in the following scenarios: * Both are null pointers. * Both point to the exact same object or function. * Both point to elements within the same array, or to one past the last element of that array. * Both point to different non-static data members of the same object, provided they share the same access control (e.g., both `public`) and are not members of a `union`. Comparing pointers that point to entirely unrelated objects yields an unspecified result. ## Operator Overloading (Pre-C++20) For user-defined types, `>=` can be overloaded. It is conventionally implemented as a non-member `friend` function to ensure symmetric implicit type conversions for both the LHS and RHS operands. To maintain mathematical consistency (strict weak ordering), `>=` is typically implemented in terms of the `<` operator rather than being written from scratch. ```cpp theme={"dark"} class Widget { public: // Implemented using the less-than operator friend bool operator>=(const Widget& lhs, const Widget& rhs) { return !(lhs < rhs); } }; ``` ## C++20 Three-Way Comparison (`<=>`) In C++20 and later, explicitly overloading the `>=` operator is generally obsolete. The language introduces the three-way comparison operator (the "spaceship" operator, `<=>`). If a class defaults `<=>`, the compiler implicitly defaults `operator==` and resolves the relational operators (`<`, `<=`, `>`, `>=`) at the call site via expression rewriting. ```cpp theme={"dark"} #include class Widget { public: // Compiler implicitly defaults == and resolves >= via expression rewriting auto operator<=>(const Widget&) const = default; }; ``` When the compiler encounters `lhs >= rhs` for a type utilizing the spaceship operator, it internally rewrites the expression as `(lhs <=> rhs) >= 0`. The result of `<=>` is a comparison category type (such as `std::strong_ordering`), which is then compared against the literal `0` to produce the final `bool`.

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More