C++ is it legal to take the address of 2 or more past the end of the array?

Question

From Take the address of a one-past-the-end array element via subscript: legal by the C++ Standard or not?

It seems that there is language specific to taking the address of one more than an array end.

Why would 2 or 2,000,000 past the end be an issue if it's not derefferenced?

Looking at some simple loop:

int array[];
...
for (int i = 0: i < array_max; ++i)
{
       int * x = &array[i *2];      // Is this legal
       int y=0;
       if (i * 2 < array_max)       // We check here before dereference
       {
              y = *x;               // Legal dereference
       }
       ...
}

Why or at what point does this become undefined, in practice it just sets a ptr to some value, why would it be undefined if it's not refferenced?

More specifically - what example of anything but what is expected to happen could there be?

Answer 1

The key issue with taking addresses beyond the end of an array are segmented architectures: you may overflow the representable range of the pointer. The existing rule already creates some level of pain as it means that the last object can't be right on the boundary of a segment. however, the ability to form this address was well established.

Answer 2

Since array[i *2] is equivalent to *((array) + (i*2)), we should look at the rules for pointer addition. C++11 §5.7 says:

If both the pointer operand and the result point to elements of the same array object, or one past the last element of the array object, the evaluation shall not produce an overflow; otherwise, the behavior is undefined.

So you have undefined behaviour even if you don't perform indirection on the pointer (not to mention that you do perform indirection, due to the expression equivalence I gave at the beginning).