Answer.

Background: In the C language, pointers are variables that store the addresses of other objects. A problem arises: how to compare such values, since memory can be allocated in the most unpredictable ways. The language allows pointer comparison but imposes a number of restrictions to keep the behavior well-defined.

The Problem: It is valid to compare only pointers to elements of the same array or to the same object. Comparing pointers that point to unrelated objects (different variables or allocated memory regions not part of a common array) results in undefined behavior.

The Solution: Avoid comparing pointers between unrelated memory areas, use it only within the bounds of the same array/string/buffer, and comparisons with NULL are safe.

Example code:

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *p1 = &arr[1];
    int *p2 = &arr[3];

    if (p1 < p2) {
        printf("p1 points to an earlier element of the array than p2
");
    }
}

Key Features:

The validity of comparing pointers is determined by their belonging to the same object.
Comparison with NULL is always safe and used for validity checks.
Comparing pointers to different objects leads to undefined behavior.

Tricky Questions.

1. Can pointers obtained through malloc and pointing to different memory blocks be compared?

No, such pointers cannot be compared — the behavior is not defined by the standard. Only pointers to the same allocated block of memory or to NULL can be compared.

2. What does comparison of pointers of type int and double return if they point to different variables but have the same numerical value?**

Comparison is only possible if both pointers are cast to the same type and point to the same object. If not, the result is undefined — the address values may be similar, but the standard does not guarantee this behavior.

3. Is it valid to compare a pointer to the first element of an array with a pointer to its end (e.g., arr and arr + N)?

Yes, this is valid. arr + N points to an imaginary element that follows the last one, and the compiler guarantees that arr <= arr + N.

Common Mistakes and Anti-Patterns

Comparing pointers to different objects
Analyzing pointer order without considering array ownership
Using comparison results to organize logic between unrelated areas

Real-Life Example

An employee decided to implement a function to compare addresses to determine "which was created first" between two structures allocated from different pieces of memory.

Pros:

Code worked on his computer

Cons:

On another architecture, some pointers turned out to be less than others, making the code's result unpredictable, with bugs manifesting rarely and randomly.

After a review, a check for pointer ownership of a single memory block was implemented by allocating all structures in a common buffer and further comparing within valid bounds.