Why is the expression index[array] equivalent to array[index]?

According to section 5.2.1 Subscripting of this working draft of the C++ standard (apparently the specifications are sold by the ISO and are not publicly available) a is defined E1[E2]as

E1[E2] == *((E1)+(E2))

where E1 and E2 are any expression

Then

arreglo[indice] == *((arreglo) + (indice))

Therefore it indice[arreglo]will be equivalent to:

indice[arreglo] == *((indice) + (arreglo))

By simple commutative property of addition we can see that both expressions give the same

In this case arregloaccording to section 4.2 Array-to-pointer conversion it is implicitly converted to the memory address of the first element of the array.

There's really no such thing as an independent data type in C++: the array syntax is just an easy way to manipulate pointers.

More specifically, matriz[indice]it's actually a more readable form of *(matriz+indice). Hence, since addition is commutative, you get the same result with indice[matriz], or what amounts to the same *(indice + matriz).

C and C++ handle arrays as a pointer to the first position of the array in memory, then accessed via the index to access each position.

That said, it turns out that the compiler converts this:

indice[arreglo]

In this:

*(indice + arreglo)

With normal syntax it would become

arreglo[indice]

in this:

*(arreglo + indice)

and therefore both expressions are equivalent and obtain the same value. This also applies to C.

Extracted from Martin Geisler 's post . See here

As you may have read in other answersE1[E2] == *((E1)+(E2))

But it's not always like this.

When an operator is overloaded, it obeys the syntax rules of the operator, but the operand type, value category, and evaluation order requirements are overridden by the rules of a function invocation, as noted in Note 2 to chapter 5 of the standard :

2 [Note: Operators can be overloaded, that is, given meaning when applied to expressions of class type (Clause 9) or enumeration type (7.2). Uses of overloaded operators are transformed into function calls as described in 13.5. Overloaded operators obey the rules for syntax specified in Clause 5, but the requirements of operand type, value category, and evaluation order are replaced by the rules for function calls. Relations between operators, such as ++a meaning a+=1, are not guaranteed for overloaded operators (13.5), and are not guaranteed for operands of type bool. —end note]

This is easy to check with the following program:

#include<vector>
#include<stdlib.h>

class MiVector
{
public:
    MiVector(size_t s):v(s) {};
    int& operator[](size_t i) { return v[i]; };

private:
    std::vector<int> v;
};

int main()
{
    int vecA[10];
    // Las siguientes dos líneas son equivalentes.
    vecA[3] = 5;
    3[vecA] = 5;

    MiVector vecB(10);
    // Las siguientes dos líneas no son equivalentes.
    vecB[3] = 5;
//    3[vecB] = 5;  // Esta línea da un error de compilación
    return 0;
}

indice[arreglo]is the syntactic sugar of *(indice+arreglo), knowing that and since it (x + y)is commutative you could also do it like this *(arreglo+indice)and get the same result.

  int main()
  {
  int arreglo[] = { 0, 1, 2, 3 };
  int indice = 0;
  std::cout << arreglo[indice] << "\n";
  indice++;
  std::cout << arreglo[indice] << "\n";
  indice++;

  std::cout << indice[arreglo] << "\n";
  std::cout << *(indice+arreglo) << "\n";
  std::cout << *(arreglo+indice) << "\n";

  indice++;
  std::cout << arreglo[indice] << "\n";
  }

Shell:

$ ./prueba
0
1
2
2
2
3

Since the topic was revived, I take the opportunity to say that I think the explanations that clarify the reason for array[indice] == indice[array], when that is true, are very good; Well, I agree with almost all the answers.

But it would be necessary to add that this equality is always valid in C but not always in C++; in fact many times the expression indice[array]doesn't make sense, it's not a valid expression (and fortunately it doesn't compile either).

The difference is that in C++ the expression E1[E2] == *((E1)+(E2))has an additional condition:

C++ Standard [8.2.1 Subscripting]

One of the expressions shall be a glvalue of type “array of T ” or a prvalue of type “pointer to T ” and the other shall be a prvalue of unscoped enumeration or integral type.

In expressions compatible with C there is no problem, because one of these Eexpressions is always a pointer to T(or decays into a pointer to T), but it is not necessarily always so.

Example. Here, overloading the [] operator gives meaning to terna[indice], but it is not possible to do indice[terna]:

struct Mi_terna {
    int& operator[](int i) { return n[i]; }
    int n[3];
};

int main()
{
     Mi_terna terna { 1, 2, 3 };
     int indice = 0;

     terna[indice] = 9;  // bien, invoca Mi_terna::operator[](int)
     indice[terna] = 9;  // mal, no hay int::operator[](Mi_terna) 
}