初学者C数组和增量

请原谅我的业余爱好，但我真的很难理解基本的递增机制。评论正确吗

#include <stdio.h>

main()
{
int a[5]={1,2,3,4,5};
int i,j,m;
i = ++a[1]; // the value of a[1] is 3. i=3
j = ++a[1]; /* because of the previous line a[1]=3 
and now a[1]=4? but not in the line defining i? */
m = a[i++];  /* i retained the value of 3 even though the value of a[1] has changed
so finally i++ which is incremented in printf()? */
printf("%d, %d, %d", i,j,m);    
}

#包括
main（）
{
int a[5]={1,2,3,4,5}；
int i，j，m；
i=++a[1]；//a[1]的值是3。i=3
j=++a[1]；/*因为前一行a[1]=3
现在a[1]=4？，但不在定义i的直线上*/
m=a[i++]；/*即使a[1]的值已更改，我仍保留了3的值
那么最后是在printf（）中递增的i++吗*/
printf（“%d，%d，%d”，i，j，m）；
}

---

我可以回答我自己的问题，但到目前为止，我已经愚弄了自己好几次了。

I=++a[1]

将

a[1]

的值增加到

3

，而

+a[1]

的结果即

3

将分配给

I

j=++a[1]

将

a[1]

的值增加到

4

，并且

++a[1]

的结果即

4

将分配给

j

---

m=a[i++]

将

a[3]

的值（因为

i

现在是3b）分配给

m

，该值为

4

，

i

将增加

1

。现在

i

变成

4

i=++a[1]

将

a[1]

的值增加到

3

，并且

++a[1]

的结果即

3

将被分配给

i

j=++a[1]

将

a[1]

的值增加到

4

，并且

++a[1]

的结果即

4

将分配给

j

---

m=a[i++]

将

a[3]

的值（因为

i

现在是3b）分配给

m

，该值为

4

，

i

将增加

1

。现在，

i

变成了

4

使用

++

和

--

运算符要记住的是表达式有结果和副作用。

++i

的结果是

i

加上

1

的原始值。

++i

的副作用是将

1

添加到

i

中存储的值中

因此，如果

i

最初是

0

，那么在表达式中

j = ++i

j

获取

0+1

的结果（

i

的原始值加上

1

）。作为副作用，

1

被添加到当前存储在

i

中的值中。因此，在计算该表达式之后，

i

和

j

都包含

1

++

的后缀版本略有不同；

i++

的结果是

i

的原始值，但副作用是相同的-

1

被添加到

i

中存储的值中。因此，如果

i

最初是

0

，那么

j = i++;

j

获取

i

（

0

）的原始值，并将

1

添加到

i

中存储的值中。在这个表达式之后，

j

是

0

，

i

是

1

重要-未指定执行

j

赋值和

i

副作用的确切顺序<在分配

j

之前，不必更新code>i，反之亦然。因此，

++

和

--

的某些组合（包括但不限于

i=i++

、

i++*i++

、

a[i++]=i

和

a[i]=i++

）将导致未定义的行为；结果将不可预测地发生变化，这取决于平台、优化和周围的代码

那么，让我们想象一下，您的对象在内存中的布局如下：

   +---+
a: | 1 | a[0]
   +---+
   | 2 | a[1]
   +---+
   | 3 | a[2]
   +---+
   | 4 | a[3]
   +---+
   | 5 | a[4]
   +---+
i: | ? |
   +---+
j: | ? |
   +---+
m: | ? |
   +---+

首先我们评估

i = ++a[1];

++a[1]

的结果是

a[1]

的原始值加1-在本例中为

3

。副作用是更新

a[1]

中的值。在此语句之后，对象现在看起来如下所示：

   +---+
a: | 1 | a[0]
   +---+
   | 3 | a[1]
   +---+
   | 3 | a[2]
   +---+
   | 4 | a[3]
   +---+
   | 5 | a[4]
   +---+
i: | 3 |
   +---+
j: | ? |
   +---+
m: | ? |
   +---+

现在我们执行

j = ++a[1];

相同的交易-

j

获得

a[1]

加1的值，副作用是更新

a[1]

。经过评估，我们有

   +---+
a: | 1 | a[0]
   +---+
   | 4 | a[1]
   +---+
   | 3 | a[2]
   +---+
   | 4 | a[3]
   +---+
   | 5 | a[4]
   +---+
i: | 3 |
   +---+
j: | 4 |
   +---+
m: | ? |
   +---+

最后，我们有

m = a[i++];

i++

的结果是

3

，因此

m

获取存储在

a[3]

中的值。副作用是将

1

添加到

i

中存储的值中。现在，我们的物体看起来像

   +---+
a: | 1 | a[0]
   +---+
   | 4 | a[1]
   +---+
   | 3 | a[2]
   +---+
   | 4 | a[3]
   +---+
   | 5 | a[4]
   +---+
i: | 4 |
   +---+
j: | 4 |
   +---+
m: | 4 |
   +---+

---

使用

++

和

-->

运算符需要记住的是，表达式有结果和副作用。

++i

的结果是

i

加上

1

的原始值。

++i

的副作用是将

1

添加到

i

中存储的值中

因此，如果

i

最初是

0

，那么在表达式中

j = ++i

j

获取

0+1

的结果（

i

的原始值加上

1

）。作为副作用，

1

被添加到当前存储在

i

中的值中。因此，在计算该表达式之后，

i

和

j

都包含

1

++

的后缀版本略有不同；

i++

的结果是

i

的原始值，但副作用是相同的-

1

被添加到

i

中存储的值中。因此，如果

i

最初是

0

，那么

j = i++;

j

获取

i

（

0

）的原始值，并将

1

添加到

i

中存储的值中。在这个表达式之后，

j

是

0

，

i

是

1

重要-未规定执行

j

赋值和

i

副作用的确切顺序