From 82ba818ff456bcd6d56a06226e3f27e98fbb55c3 Mon Sep 17 00:00:00 2001 From: Craig Jennings Date: Thu, 14 Aug 2025 22:58:58 -0500 Subject: removing all downloaded devdocs files --- devdocs/c/language%2Foperator_comparison.html | 149 -------------------------- 1 file changed, 149 deletions(-) delete mode 100644 devdocs/c/language%2Foperator_comparison.html (limited to 'devdocs/c/language%2Foperator_comparison.html') diff --git a/devdocs/c/language%2Foperator_comparison.html b/devdocs/c/language%2Foperator_comparison.html deleted file mode 100644 index cd1e66ad..00000000 --- a/devdocs/c/language%2Foperator_comparison.html +++ /dev/null @@ -1,149 +0,0 @@ -

Comparison operators

Comparison operators are binary operators that test a condition and return 1 if that condition is logically true and 0 if that condition is false.

- - - - - - - - -
Operator Operator name Example Description
== equal to a == b a is equal to b
!= not equal to a != b a is not equal to b
< less than a < b a is less than b
> greater than a > b a is greater than b
<= less than or equal to a <= b a is less than or equal to b
>= greater than or equal to a >= b a is greater than or equal to b

Relational operators

The relational operator expressions have the form

- - - - - -
lhs < rhs (1)
lhs > rhs (2)
lhs <= rhs (3)
lhs >= rhs (4)
-1) less-than expression
-2) greater-than expression
-3) less or equal expression
-4) greater or equal expression

where

- - -
lhs, rhs - expressions that both have real type or both have pointer to object type
-

The type of any relational operator expression is int, and its value (which is not an lvalue) is 1 when the specified relationship holds true and ​0​ when the specified relationship does not hold.

-

If lhs and rhs are expressions of any real type, then

-

Note that complex and imaginary numbers cannot be compared with these operators.

-

If lhs and rhs are expressions of pointer type, they must be both pointers to objects of compatible types, except that qualifications of the pointed-to objects are ignored.

- 
#include <assert.h>
-int main(void)
-{
-    assert(1 < 2);
-    assert(2+2 <= 4.0); // int converts to double, two 4.0's compare equal
- 
-    struct { int x,y; } s;
-    assert(&s.x < &s.y); // struct members compare in order of declaration
- 
-    double d = 0.0/0.0; // NaN
-    assert( !(d < d) );
-    assert( !(d > d) );
-    assert( !(d <= d) );
-    assert( !(d >= d) );
-    assert( !(d == d) );
- 
-    float f = 0.1; // f = 0.100000001490116119384765625
-    double g = 0.1; // g = 0.1000000000000000055511151231257827021181583404541015625
-    assert(f > g); // different values
-}

Equality operators

The equality operator expressions have the form

- - - -
lhs == rhs (1)
lhs != rhs (2)
-1) equal-to expression
-2) not equal to expression

where

- - -
lhs, rhs - expressions that - -
    -
  • both have type nullptr_t
    • -
  • one has type nullptr_t and the other is a null pointer constant
    • -
 (since C23)
    -
  • both are pointers to objects or functions of compatible types, ignoring qualifiers of the pointed-to types
    • -
  • one is a pointer to object and the other is a pointer to (possibly qualified) void
    • -
  • one is a pointer to object or function and the other is a null pointer constant such as NULL or nullptr(since C23)
    • -
-

The type of any equality operator expression is int, and its value (which is not an lvalue) is 1 when the specified relationship holds true and ​0​ when the specified relationship does not hold.

- - -
(since C23)

(as with relational operators, pointers to objects that aren't elements of any array behave as pointers to elements of arrays of size 1)

-

Notes

Objects of struct type do not compare equal automatically, and comparing them with memcmp is not reliable because the padding bytes may have any values.

-

Because pointer comparison works with pointers to void, the macro NULL may be defined as (void*)0 in C, although that would be invalid in C++ where void pointers do not implicitly convert to typed pointers

-

Care must be taken when comparing floating-point values for equality, because the results of many operations cannot be represented exactly and must be rounded. In practice, floating-point numbers are usually compared allowing for the difference of one or more units of the last place.

-
#include <assert.h>
-int main(void)
-{
-    assert(2+2 == 4.0); // int converts to double, two 4.0's compare equal
- 
-    int n[2][3] = {1,2,3,4,5,6};
-    int* p1 = &n[0][2]; // last element in the first row
-    int* p2 = &n[1][0]; // start of second row
-    assert(p1+1 == p2); // compare equal
- 
-    double d = 0.0/0.0; // NaN
-    assert( d != d ); // NaN does not equal itself
- 
-    float f = 0.1; // f = 0.100000001490116119384765625
-    double g = 0.1; // g = 0.1000000000000000055511151231257827021181583404541015625
-    assert(f != g); // different values
-}

References

See also

Operator precedence

- - - -
Common operators
assignment increment
decrement 		arithmetic logical comparison member
access 		other

a = b a += b a -= b a *= b a /= b a %= b a &= b a |= b a ^= b a <<= b a >>= b

-

++a --a a++ a--

-

+a -a a + b a - b a * b a / b a % b ~a a & b a | b a ^ b a << b a >> b

-

!a a && b a || b

-

a == b a != b a < b a > b a <= b a >= b

-

a[b] *a &a a->b a.b

-

a(...) a, b (type) a a ? b : c sizeof

_Alignof
(since C11)

-
-
C++ documentation for Comparison operators
-

- © cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
- https://en.cppreference.com/w/c/language/operator_comparison -

-
-- cgit v1.2.3