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

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指针和数组并不相同，尽管在这种情况下，差异并不是本质的。

考虑以下声明：

int a[10];
int* p = a;

在a.out中，符号a位于数组开始的地址，符号p位于存储指针的地址，指针在该内存位置的值是数组的开始。

我认为其他答案遗漏了一些东西。

是的，p[i]根据定义等价于*（p+i），*（i+p）（因为加法是可交换的）等效于*（i+p），而*（i+p）（同样，根据[]算子的定义）等效于i[p]。

（在array[i]中，数组名称隐式转换为指向数组第一个元素的指针。）

但在这种情况下，加法的交换性并不那么明显。

当两个操作数都是同一类型，甚至是不同的数字类型，并被提升为一个公共类型时，交换性就非常有意义：x+y==y+x。

但在本例中，我们具体讨论的是指针算术，其中一个操作数是指针，另一个是整数。（整数+整数是不同的操作，指针+指针是无意义的。）

C标准对+运算符的描述（N1570 6.5.6）表示：

对于加法，两个操作数都应为算术类型，或一个操作数应是指向完整对象类型的指针应为整数类型。

它可以很容易地说：

对于加法，两个操作数都应为算术类型，或左侧操作数应是指向完整对象类型和正确操作数的指针应为整数类型。

在这种情况下，i+p和i[p]都是非法的。

在C++术语中，我们确实有两组重载+运算符，可以粗略地描述为：

pointer operator+(pointer p, integer i);

and

pointer operator+(integer i, pointer p);

其中只有第一个是真正必要的。

那么为什么会这样呢？

C++继承了C的这一定义，后者从B获得了它（数组索引的交换性在1972年的《用户参考B》中明确提到），后者从BCPL（1967年的手册）获得了它，BCPL很可能是从更早的语言（CPL？Algol？）获得的。

因此，数组索引是用加法来定义的，即使是指针和整数的加法，也是可交换的，这一想法可以追溯到几十年前，直到C的祖先语言。

这些语言比现代C语言的强类型少得多。特别是，指针和整数之间的区别经常被忽略。（在无符号关键字被添加到语言中之前，早期的C程序员有时将指针用作无符号整数。）因此，由于操作数的类型不同，所以使加法不可交换的想法可能不会出现在这些语言的设计者身上。如果用户想添加两个“东西”，无论这些“东西”是整数、指针还是其他东西，都不能由语言来阻止。

多年来，对该规则的任何修改都会破坏现有的代码（尽管1989年的ANSI C标准可能是一个很好的机会）。

更改C和/或C++以要求将指针放在左边，将整数放在右边，这可能会破坏一些现有代码，但不会损失真正的表达能力。

所以现在我们有了arr[3]和3[arr]，意思完全相同，尽管后一种形式不应该出现在IOCCC之外。

它在C语言中的指针和阵列教程中有很好的解释由Ted Jensen撰写。

Ted Jensen解释为：

事实上，这是真的，也就是说，无论你在哪里写一个替换为*（a+i）而没有任何问题。事实上，编译器将在任何情况下创建相同的代码。因此，我们看到了指针算术与数组索引相同。任一语法都会产生同样的结果。这并不是说指针和数组是一样的东西，它们不是。我们这么说只是为了确定对于数组的给定元素，我们可以选择两种语法，一种使用数组索引，另一种使用指针算法产生相同的结果。现在，看看最后一个表达式的一部分..（a+i）是使用+运算符和C的规则声明这样的表达式是交换的。即（a+i）与（i+a）相同。因此，我们可以写*（i+a）和*（a+i）一样容易。但*（i+a）可能来自i[a]！所有这些都带来了好奇如果：字符a[20]；写a[3]=“x”；与写作相同3[a]=“x”；

当然，还有

 ("ABCD"[2] == 2["ABCD"]) && (2["ABCD"] == 'C') && ("ABCD"[2] == 'C')

其主要原因是，在70年代设计C时，计算机没有太多内存（64KB是很多），因此C编译器没有做太多语法检查。因此，“X[Y]”相当盲目地翻译为“*（X+Y）”

这也解释了“+=”和“++”语法。“A=B+C”形式的所有对象都具有相同的编译形式。但是，如果B是与A相同的对象，则可以进行汇编级优化。但是编译器不够明亮，无法识别它，所以开发人员不得不（A+=C）。类似地，如果C为1，则可以使用不同的汇编级优化，开发人员再次必须使其显式，因为编译器无法识别它

不是答案，只是一些思考的食物。如果类具有重载的索引/下标运算符，则表达式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&);
};