C # 中的前后增量

对于 C # 编译器如何处理前后的增量和减量，我有点困惑。

当我编写以下代码时:

int x = 4;
x = x++ + ++x;

之后 x的值为10。我认为这是因为前增量将 x设置为 5，这使得 5+5的计算结果为 10。然后后增量将更新 x到 6，但是这个值将不会被使用，因为这样 10将被分配到 x。

但是当我编码的时候:

int x = 4;
x = x-- - --x;

那么 x之后就是 2了。有人能解释一下为什么会这样吗？

35894 次浏览
小开
最佳答案

x--是4，但是在 --x的时刻是3，所以它的结尾是2，然后你就有了

x = 4 - 2

顺便说一下，你的第一个案件将是 x = 4 + 6

下面是一个小例子，它会打印出每个部分的值，也许这样你会更好地理解它:

static void Main(string[] args)
{
int x = 4;
Console.WriteLine("x++: {0}", x++); //after this statement x = 5
Console.WriteLine("++x: {0}", ++x);


int y = 4;
Console.WriteLine("y--: {0}", y--); //after this statement y = 3
Console.WriteLine("--y: {0}", --y);


Console.ReadKey();
}

这个能打印出来

x++: 4
++x: 6
y--: 4
--y: 2
小开

我认为对“ + + + +”的解释是错误的:

命令 x 的值

未定义

Int x = 4... ... 4

X + + ... ... ... ... 5(第一个和是4)

+ + x... ... ... ... 6(第二个和是6)

X = summand1 + summand2. . 4 + 6 = 10

类似的解释是

命令 x 的值

未定义

Int x = 4... ... 4

X —— ... ... ... ... 3(减法器是4)

—— x... ... ... ... 2(减去2)

X = 减法-减法. . 4-2 = 10

小开

让我们看看从该语句生成的 IL

IL_0002:  ldloc.0

将 x 的值加载到堆栈上

IL_0003:  dup

复制堆栈上最上面的项

IL_0004:  ldc.i4.1

将1推入堆栈，堆栈 = > (1,4,4)

IL_0005:  sub

减去两个 top 值并将结果推送到堆栈上

IL_0006:  stloc.0

将堆栈的最高值存储回 x.Stack = > (4)

IL_0007:  ldloc.0

将 x 的值加载回堆栈中

IL_0008:  ldc.i4.1

将值1加载到堆栈上

IL_0009:  sub

减去2. Stack = > (2,4)

IL_000A:  dup

复制顶部值 = > (2,2,4)

IL_000B:  stloc.0

将顶部值存储回 x.Stack = > (2,4)

IL_000C:  sub

减去两个最大值. Stack = > (2)

IL_000D:  stloc.0

将此值存储回 x.X = = 2

小开

在这个例子中,

int x = 4;
x = x++ + ++x;

你可以这样打破它:

x = 4++; which is = 5
x = 4 + ++5; which is 4 + 6
x = 10

同样地,

int x = 4;
x = x-- - --x;

给你,

x = 4--; which is = 3
x = 4 - --3; which is 4 - 2
x = 2

简单地说，可以替换 x 的当前值，但是对于每个 + + 或者——从 x 中加/减一个值。

小开

最有趣的是，你会得到一个完全不同的答案与 C + + .Net 编译器。

int x = 4;
x = x++ + ++x; // x = 11
x = 4;
x = x-- - --x; // x = -1

当然，结果的差异是由不同的 语义学决定的，这似乎是正常的。但是尽管我们知道。网络编译器不会以类似的方式运行，因为这些基本的东西也让我感到困惑。

小开

根据你的评论:

我认为后增量和前增量是在对完整代码线求值之后或之前执行的——但是它们是在表达式中每个项求值之后或之前执行的。

你的误解是非常普遍的。请注意，在某些语言中，比如 C，没有指定副作用何时变得可见，因此在 C 中语句为 true 是合法的，但不是必需的。

在 C # 中不是这样; 在 C # 在执行右边的代码之前，总是观察到表达式左边的代码的副作用中(来自单个线程; 在多线程的场景中，所有的赌注都是错误的)

有关增量运算符在 C # 中的作用的更详细说明，请参见:

I + + 和 + + i 的区别是什么？

这里有很多额外的链接，链接到我写的关于这个经常被误解的话题的文章。


提交答案