正如Joel 在C编程语言（又名：K＆R）中的Stack Overflow podcast＃34中指出的那样，在C中提到了数组的此属性：a[5] == 5[a]

乔尔（Joel）说，这是因为指针运算，但是我还是不明白。为什么a[5] == 5[a]呢？

C标准将[]运算符定义如下：

a[b] == *(a + b)

因此a[5]将评估为：

*(a + 5)

并且5[a]将计算为：

*(5 + a)

a是指向数组第一个元素的指针。a[5]是距，与相同的5个元素的值，从小学数学我们知道它们是相等的（加法是可交换的）。a*(a + 5)

因为数组访问是根据指针定义的。 a[i]定义为*(a + i)，是可交换的。

我认为其他答案缺少一些东西。

是的，p[i]根据定义*(p+i)，它等于，（由于加法是可交换的）等于*(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);

和

pointer operator+(integer i, pointer p);

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

那么为什么会这样呢？

C ++从C继承了这个定义，而C则从B得到了它（1972年用户参考B明确提到了数组索引的可交换性），而BCPL则得到了它。（1967年手册）得到的，甚至可能从早期语言（CPL？Algol？）。

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

与现代C语言相比，这些语言的强类型要少得多。特别是，指针和整数之间的区别通常被忽略。（在将unsigned关键字添加到语言之前，早期的C程序员有时将指针用作无符号整数。）因此，由于操作数的类型不同，使这些语言的设计人员可能不会想到使加法运算不可交换。如果用户想添加两个“事物”，无论这些“事物”是整数，指针还是其他事物，都无法阻止该语言。

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

更改C和/或C ++要求将指针放在左侧，将整数放在右侧可能会破坏某些现有代码，但不会损失实际的表达能力。

因此，现在我们拥有arr[3]和3[arr]意义完全相同的东西，尽管后者永远不应出现在IOCCC之外。

而且当然

 ("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，则可以使用不同的程序集级别优化，并且开发人员必须再次使其明确，因为编译器无法识别它。（最近，编译器会这样做，因此，如今这些语法在很大程度上是不必要的）

关于戴娜（Dinah）的问题，似乎没有人提到过一件事 sizeof：

您只能将整数添加到指针，不能将两个指针添加在一起。这样，当将指针添加到整数或将整数添加到指针时，编译器始终知道哪位的大小需要考虑。

从字面上回答这个问题。并非总是如此x == x

double zero = 0.0;
double a[] = { 0,0,0,0,0, zero/zero}; // NaN
cout << (a[5] == 5[a] ? "true" : "false") << endl;

版画

false

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

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位于存储指针的地址，指针在该内存位置的值是数组的开头。

对于C中的指针，我们有

a[5] == *(a + 5)

并且

5[a] == *(5 + a)

因此，的确 a[5] == 5[a].

不是答案，而是一些值得深思的地方。如果类具有重载的索引/下标运算符，则该表达式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&);
};

在《 C语言中的指针和数组教程》中有很好的解释 Ted Jensen的。

泰德·詹森（Ted Jensen）解释为：

实际上，这是对的，也就是说，无论在哪里写a[i]，都可以用*(a + i) 毫无问题。实际上，无论哪种情况，编译器都会创建相同的代码。因此，我们看到指针算术与数组索引是同一回事。两种语法都会产生相同的结果。

这并不是说指针和数组是同一回事，它们不是。我们只是说要确定数组的给定元素，我们可以选择两种语法，一种使用数组索引，另一种使用指针算法，它们产生相同的结果。

现在，看最后一个表达式，它的一部分.. (a + i)是使用+运算符和C规则的简单加法，该表达式是可交换的。即（a + i）等于(i + a)。因此，我们可以*(i + a)像一样轻松地编写*(a + i)。但是*(i + a)可能来自i[a]！所有这些都产生了一个奇怪的事实，即：

char a[20];

写作

a[3] = 'x';

和写作一样

3[a] = 'x';

我知道问题已经解决，但我无法抗拒分享这个解释。

我记得编译器设计原理，假设a是一个int数组，大小int为2个字节，＆的基址为a1000。

怎么a[5]工作->

Base Address of your Array a + (5*size of(data type for array a))
i.e. 1000 + (5*2) = 1010

所以，

类似地，当c代码分解为3地址代码时， 5[a]将变为->

Base Address of your Array a + (size of(data type for array a)*5)
i.e. 1000 + (2*5) = 1010 

因此，基本上，这两个语句都指向内存中的同一位置，因此， a[5] = 5[a]。

这也是数组中的负索引在C中起作用的原因。

即，如果我访问a[-5]它将给我

Base Address of your Array a + (-5 * size of(data type for array a))
i.e. 1000 + (-5*2) = 990

它将向我返回位置990处的对象。

在C数组中，arr[3]和3[arr]相同，它们的等效指针符号*(arr + 3)为*(3 + arr)。但是相反[arr]3还是[3]arr不正确，将导致语法错误，因为(arr + 3)*和(3 + arr)*不是有效的表达式。原因是取消引用运算符应放置在表达式产生的地址之前，而不是地址之后。

在C编译器中

a[i]
i[a]
*(a+i)

是引用数组中元素的不同方法！（一点也不奇怪）

现在的历史。在其他语言中，BCPL对C的早期发展有相当大的影响。如果您在BCPL中声明了类似以下内容的数组：

let V = vec 10

实际上分配了11个内存字，而不是10个字。通常V是第一个，并且包含紧随其后的字的地址。因此，与C不同，命名V到该位置并获取数组的zeroeth元素的地址。因此，BCPL中的数组间接表示为

let J = V!5

确实确实需要做J = !(V + 5)（使用BCPL语法），因为有必要获取V以获取数组的基地址。因此V!5，5!V是同义词。有趣的是，WAFL（Warwick函数语言）是用BCPL编写的，据我所知，它倾向于使用后一种语法而不是前一种语法来访问用作数据存储的节点。当然，这是在35到40年前之间的某个地方，所以我的记忆有点生锈。:)

后来又有了创新，省去了多余的存储字并让编译器在命名数组时插入了数组的基地址。根据C历史记录，这大约是在将结构添加到C时发生的。

请注意，!在BCPL中，既是一元前缀运算符，又是二进制中缀运算符，在两种情况下都是间接的。只是二进制形式在执行间接操作之前将两个操作数相加。考虑到BCPL（和B）的面向单词的性质，这实际上很有意义。当获取数据类型并sizeof成为事实时，在C中就需要“指针和整数”的限制。

嗯，这是仅由于语言支持才可能实现的功能。

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

在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++无效

a[2] 等于2 [a]，因为这两者的内部运算都是

内部计算的“指针算术”为

*(a+3) 等于 *(3+a)

指针类型

1）指向数据的指针

int *ptr;

2）const指向数据的指针

int const *ptr;

3）指向const数据的const指针

int const *const ptr;

并且数组是列表中（2）的类型
当您一次在该指针中初始化一个地址时定义数组时 我们知道我们无法在程序中更改或修改const值，因为它在编译时会引发ERROR时间

我发现的主要区别是...

我们可以通过地址来重新初始化指针，但数组不能相同。

======
回到你的问题...
a[5]不过是*(a + 5)
您可以通过
a -包含地址（人们称其为基地址）很容易理解 -就像我们列表中的（2）类型的指针一样
[]-该运算符可以是可用指针替换*。

所以最后...

a[5] == *(a +5) == *(5 + a) == 5[a]