我只是发现这种丑陋的语法可能是“有用的”，或者至少当你想处理一个索引数组，这些索引引用了同一个数组中的位置时，使用起来非常有趣。它可以替换嵌套的方括号，使代码更可读！

int a[] = { 2 , 3 , 3 , 2 , 4 };
int s = sizeof a / sizeof *a;  //  s == 5

for(int i = 0 ; i < s ; ++i) {  
           
    cout << a[a[a[i]]] << endl;
    // ... is equivalent to ...
    cout << i[a][a][a] << endl;  // but I prefer this one, it's easier to increase the level of indirection (without loop)
    
}

当然，我很确定在实际代码中没有这样的用例，但我还是觉得很有趣：）

在C数组中，arr[3]和3[arr]是相同的，它们的等价指针符号是*（arr+3）到*（3+arr）。但相反，[arr]3或[3]arr不正确，会导致语法错误，因为（arr+3）*和（3+arr）*不是有效表达式。原因是解引用运算符应该放在表达式产生的地址之前，而不是地址之后。

因为避免混淆嵌套非常有用。

你愿意读这个吗

array[array[head].next].prev

或者：

head[array].next[array].prev

顺便说一下，C++对于函数调用具有类似的交换性质。您可以使用成员函数来编写x.f（）.g（），而不是像在C中那样编写g（f（x））。用查找表替换f和g，您可以编写g[f[x]]（函数样式）或（x[f]）[g]（oop样式）。后者非常适合包含索引的结构：x[xs].y[ys].z[zs]。使用更常见的符号zs[ys[xs[x].y].z]。

嗯，这是一个只有语言支持才能实现的功能。

编译器将a[i]解释为*（a+i），表达式5[a]的计算结果为*（5+a）。由于加法是可交换的，结果证明两者相等。因此，表达式的计算结果为true。

不是答案，只是一些思考的食物。如果类具有重载的索引/下标运算符，则表达式0[x]将不起作用：

class Sub
{
public:
    int operator [](size_t nIndex)
    {
        return 0;
    }   
};

int main()
{
    Sub s;
    s[0];
    0[s]; // ERROR 
}

由于我们无法访问int类，因此无法执行此操作：

class int
{
   int operator[](const Sub&);
};

In C

 int a[]={10,20,30,40,50};
 int *p=a;
 printf("%d\n",*p++);//output will be 10
 printf("%d\n",*a++);//will give an error

指针p是“变量”，数组名称a是“助记符”或“同义词”，因此p++有效，而a++无效。

a[2]等于2[a]，因为这两者的内部运算都是“指针算术”，内部计算为*（a+2）等于*（2+a）