增量、前增量和后增量

Question

请帮我解决这个问题。该表达式遵循的步骤是：

//Expression
offSpring1[m1++] = temp1;

//步骤：

1.- 增加 m1

2.- 将 temp1 分配给 offSpring

我一直认为括号内的表达式是首先要做的。但现在我很困惑。所以如果这样写：

//Expression
offSpring1[++m1] = temp1;

//步骤是：

1.- 将 temp1 分配给 offSpring
2.- 增加 m1

如果步骤与第一个相同，那么 i++ 和 ++i 之间有什么区别？

Answer 1

int i = 0;
std::cout << i++ << std::endl;
std::cout << i << "\nreset" << std::endl;
i = 0;
std::cout << ++i << std::endl;
std::cout << i << std::endl;

输出：

0
1
reset
1
1

i++ 返回表达式中当前的值，然后递增变量。
++i 将递增变量，然后返回要在当前表达式中使用的值。

Answer 2

offSpring1[m1++] = temp1;

是

offSpring1[m1] = temp1;
m1 += 1;

并且

offSpring1[++m1] = temp1;

是

m1 += 1;
offSpring1[m1] = temp1;

Answer 3

• j = ++i 与 i = i+1 相同； j = i;
• j = i++ 与 j = i; 相同我=我+1;

Answer 4

只需运行这两个不同的测试程序即可了解后自增和预自增运算符之间的差异

对于 ++i（前自增）

int main()
{
    int* offSpring = calloc(20,sizeof(int));
    int m1 =1;
    offSpring[++m1] = 10;
    printf("%d,%d",offSpring[m1],m1);
}

在第一个程序中，您将得到 10 作为值关闭弹簧[m1]。
为什么？因为这是预递增运算符，这意味着第一个 m1 递增，其余的进行评估。

对于 i++（后增量）

int main()
{
    int* offSpring = calloc(20,sizeof(int));
    int m1 =1;
    offSpring[m1++] = 10;
    printf("%d,%d",offSpring[m1],m1);
}

在第二个中，因为使用了后增量运算符，您将得到 0 值，因为您首先将 10 分配给 offSpring[m1]，然后 m1 递增。

Answer 5

offSpring1[m1++] = temp1; 不执行您所说的操作。

1. 指定 temp_m1 = m1。
2. 增量 m1。
3. 索引 offSpring1[temp_m1]
4. 将 temp1 分配给索引值。

另一方面，offSpring1[++m1] = temp1; 的工作原理如下：

1. 递增 m1。
2. index offSpring1[m1]
3. 将 temp1 分配给索引值。

Answer 6

尽管后缀增量是第一个示例中第一个被评估的，但它的值是被增量的变量的原始值。

offSpring1[m1++] = temp1;

因此，即使 m1 在数组索引之前递增，temp1 的值也会分配到位置 m1 - 1 处。

Answer 7

表达式（或子表达式）有两个方面：它的值，
及其副作用。 i++的值就是i的值；这
++ i 的值是值 i + 1，转换为 i 的类型。
这是表达式中使用的值。两者的副作用是
增加变量i。这可能发生在
前面的序列点和下一个序列点之前。假设 i 是一个全局变量
变量，并且您编写如下内容：

i = 0;
f()[i ++] = g();
f()[++ i] = g();

标准没有说明 i 的值是否在 f() 中出现
或g() 是增量之前或之后。在这两种情况下。
标准所说的只是增量的效果将
发生在完整表达式开始之后（但也许作为
完整表达中的第一件事）和结束之前。 （还有那个
它们不会与函数调用交错，因此 if f()
读取 i 两次，保证看到相同的值。）

Answer 8

不幸的是，在您发布的那两个代码片段中，没有保证评估的顺序。如果你的表达不恰当，或多或少就会发生什么事情。

首先从 a++ 和 ++a 之间的区别开始：

• a++ 会递增 a，但使用它的表达式将在递增之前看到 a 的值
• ++a 将递增 a，并且使用它的表达式将看到递增后的值。
• 项

列表

buffer[a++] = b;

编译器可以决定在表达式中的任何点执行 ++ 的 。因此，如果“b”实际上是涉及 a 的表达式，则可以在不同的编译器上得到不同的结果。以下两者都是有效的：

• 获取 a 的值；
• 递增 a
• 计算其中 buffer[old value] 指向
• 评估 b
• store b

或 this

• 评估 b;
• 计算出 buffer[a] 指向
• 存储 b
• 增量 a 的

位置，如果 'b' 碰巧涉及 a，这两种实现将产生不同的结果。两者都有效。

Answer 9

它的工作原理与您所描述的完全相反：

offSpring1[m1++] = temp1 与
offSpring[m1] = temp1; m1 = m1 + 1;

OffSpring1[++m1] = temp1 与
m1 = m1 + 1； OffSpring1[m1] = temp1;

在计算表达式之前前缀表示法递增
计算表达式后后缀表示法递增

Answer 10

第一个的描述是第二个的正确描述。第一个的正确描述非常相似，您只需要在其他步骤之前添加“复制 m1 的当前值”步骤即可。

但是，如果 m1 具有原始类型，那么这里确实明显缺乏序列点。 C++03 和 C++11 之间的规则略有变化。

如果m1具有用户定义的类型，则涉及影响排序的函数调用。

---

此代码

offSpring1[m1++] = temp1;

执行以下操作（如果 m1 是基本类型）：

auto const old_m1(m1);
auto const new_m1(old_m1 + 1);
auto& lhs(offSpring[old_m1]);
parallel { lhs = temp1; m1 = new_m1; }

此代码

offSpring1[++m1] = temp1;

完全相同，只是 lhs 使用 new_m1 绑定，而不是使用 new_m1 old_m1。

无论哪种情况，都未指定 lhs 是写入 m1 之前还是之后。

如果 m1 不是原始类型，它看起来更像：

auto const& index = m1.operator++(0); // one argument
auto& lhs = offSpring.operator[](index);
lhs = temp1;

vs

auto const& index = m1.operator++(); // no arguments
auto& lhs = offSpring.operator[](index);
lhs = temp1;

在这两种情况下，对 m1 的更改肯定是在写入 lhs.