For a pointer p, could p < p+1 be false in an extreme case?

Question

Is it possible, for a pointer variable p, that p<(p+1) is false? Please explain your answer. If yes, under which circumstances can this happen?

I was wondering whether p+1 could overflow and be equal to 0.

E.g. On a 64-bit PC with GCC-4.8 for a C-language program:

int main(void) {    void *p=(void *)0xFFFFFFFFFFFFFFFF;     printf("p      :%p\n", p);    printf("p+1    :%p\n", p+1);    printf("Result :%d\n", p<p+1); } 

It returns:

p      : 0xffffffffffffffff p+1    : (nil) Result : 0 

So I believe it is possible for this case. For an invalid pointer location it can happen. This is the only solution I can think of. Are there others?

Note: No assumptions are made. Consider any compiler/platform/architecture/OS where there is a chance that this can happen or not.

Answer 1

Is it possible, for a pointer variable p, that p<(p+1) is false?

If p points to a valid object (that is, one created according to the C++ object model) of the correct type, then no. p+1 will point to the memory location after that object, and will always compare greater than p.

Otherwise, the behaviour of both the arithmetic and the comparison are undefined, so the result could be true, false, or a suffusion of yellow.

If yes, under which circumstances can this happen?

It might, or might not, happen with

p = reinterpret_cast<char*>(numeric_limits<uintptr_t>::max); 

If pointer arithmetic works like unsigned integer arithmetic, then this might cause a numeric overflow such that p+1 has the value zero, and compares less than p. Or it might do something else.