Why 5[a] with C arrays isn't out of range?

Question

Acording to the Post: With arrays, why is it the case that a[5] == 5[a]?

Where is claimed, that a[5] is equal to 5[a].

I'm asking my self, is this true?

While I aggree that E1[E2] is identical to (*((E1)+(E2)))

But I would claim: Given a declaration of

int a[sizeI];

where if (sizeI > 5) has to be true

I would aggree that a[5] is ok.

But related to the cite from ISO/IEC:9899

Apendix J.2 Undefined behavior:

— An array subscript is out of range, even if an object is apparently accessible with the given subscript (as in the lvalue expression a[1][7] given the declaration int a[4][5]) (6.5.6).

Is (if I get it correct from the document) 5[a] "apparently accessible" but the "array subscript is out of range" So I would overall disaggree to the OP I linked, as that a[5] is in the given case well defined and 5[a] is undefined behaviour.

So, am I right? Or have I forgotten to consider something important?

EDIT:

my claim doesn't imply that

E1[E2] is identical to (*((E1)+(E2)))

would be incorrect.

and also 6.5.2.1 Array subscripting point 2

just says that they are arithmeticaly identical. But nothing is said like: (*((E1)+(E2))) can't achive UB.

So while I know this section, I can't find there anything thatdestroys my claim

Also Note:

As you allready should see in my first sentence, I'm asking a different question to the related to the "problem" stated by

With arrays, why is it the case that a[5] == 5[a]?

So please stop marking it as duplicate of that one.

Answer 1

To see why the note in Appendix J.2 is compatible with a[b] being the same as *(a + b), consider how an expression like a[1][7] is interpreted (assuming the declaration int a[4][5], like in the appendix):

a[1][7] is the same as *(a[1] + 7). Each element of the array a is a five-element array, so that a[1] evaluates to a pointer to the first element of a five-element array. If you add 7 to such a pointer, then the resulting pointer will point outside the five-element array, meaning you are not allowed to dereference it (standards-wise -- it might work in practice). But that's exactly what the above expression does.

The note in Appendix J.2 has nothing to do with a[5] vs. 5[a] by the way. If the array has at least six elements, then it would be reasonable to call the element "apparently accessible" in both of those expressions. They're only trying to clarify that you're not allowed to access a multidimensional array with overflow in any of the indices, even when it looks like it shouldn't overflow the boundaries of the multidimensional array. It's just a note -- you can derive it independently (as above).

Answer 2

5 is not an array, so 5[a] is not an array subscript.

Either way, Annex J is informative which means that it is meant for extra helpfulness and not as a part of the specification. So we cannot make any claims about undefined behaviour solely based on what J.2 says.

The normative section about pointer arithmetic is 6.3.2.3 which includes the proof that 5[a] and a[5] are identical.

Answer 3

I think that it is true. Probably it is okay because it makes the same calculation like:

 *(arr + 4) // For the arr[4]
 *(4 + arr) // For the 4[arr]

Which concludes on the same result.

#include <stdio.h>

int main(void)
{
    int arr[5] = {1,2,3,4,5};
    printf("\n%d %d\n", arr[4], 4[arr]);
    printf("\n%d %d\n", arr[5], 5[arr]);
    printf("\n%d %d\n\n", arr[6], 6[arr]);

    return 0;
}

In each printf the behaviour will be as expected.