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.

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.

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.

#include <compare>

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.

Master C++ with Deep Grasping Methodology!

Learn More