Why array subscription operator works both ways?

Question

Why does C++ allow the following statement?

  int a[10] = { 0 };
  std::cout << 1[a] << std::endl;
  std::cout << a[1] << std::endl;

Both lines print zero and no compiler warning is generated. Shouldn't 1[a] be illegal as 1 is not an array and a is not an integer type.

Code example : http://cpp.sh/4tan

Because of pointer arithmetic. – abhishek_naik Jun 30 '16 at 16:38 — abhishek_naik, Jun 30 '16 at 16:38
Ask the C standard, that's where C++ got its arithmetic – KABoissonneault Jun 30 '16 at 16:39 — KABoissonneault, Jun 30 '16 at 16:39

abhishek_naik · Accepted Answer · 2016-06-30T17:23:42.810

4

It is because of pointer arithmetic:

a[1] == *(a+1) == *(1+a) == 1[a];

Quoting the standard (§8.3.4; point 6):

Except where it has been declared for a class, the subscript operator [] is interpreted in such a way that E1[E2] is identical to *((E1)+(E2)). Because of the conversion rules that apply to +, if E1 is an array and E2 an integer, then E1[E2] refers to the E2-th member of E1. Therefore, despite its asymmetric appearance, subscripting is a commutative operation.

Note that when you write a[1], the compiler interprets it as *(a+1). You are still referring the same array a when you write 1[a], so the compiler is infact still doing type checking.

edited Jun 30 '16 at 17:23

answered Jun 30 '16 at 16:40

abhishek_naik

1,287
2
15
27

I get that, but why it doesn't perform any type checking? – Giuseppe Pes Jun 30 '16 at 16:41
maybe better illustrated with `==`? `assert(a[1] == *(a+1) == *(1+a) == 1[a]);` – Steve Lorimer Jun 30 '16 at 16:41
@BatCoder I think OP is assuming `operator[]` is only valid for pointer types, array types and user-defined types that overload the operator. But as shown in the question, it's not. – KABoissonneault Jun 30 '16 at 16:48
@Giuseppe - It *does* type checking. But as `a[b]` is the same as `*(a+b)`, the order of `a` and `b` doesn't matter. – Bo Persson Jun 30 '16 at 16:48
@GiuseppePes, please check my edit. Hope this is useful. – abhishek_naik Jun 30 '16 at 17:36

score 1 · Answer 2 · answered Jun 30 '16 at 16:42

Both are fine since under the covers it's all just pointer arithmetic. Taking the address of something and adding something else to it (a[1) is exactely the same as taking something else and adding an address to it (1[a]) - the final address of the object you refer to is the same. One notation is just more intuitive to humans than the other.

Why array subscription operator works both ways?

2 Answers2