x += x++

id 188888 — юбилейный пост.

А вообще, об этом уже писали на хабре. Насколько я помню, автор закрыл пост.

> Первое, что делает компилятор, когда видит код z += y это преобразует его в z = z + y
И это не совсем верно.

Правильный ответ 6. x += x будет выполнен. ++ пролетит мимо.

Но для начала, НИКОГДА НЕ ПИШИТЕ ТАКОЙ КОД.

Где подписаться? В самом деле, если код вызывает затруднения при прочтении и понимании, и, более того, может иметь неоднозначную интерпретацию в разных ЯП — вот сразу нахрен такой код, а автора бить нещадно клавиатурой по руках.

Не понимаю, почему столько людей выбрало 7?
x += n всегда разворачивается в x = x+n, а не n+x.
К чему эти теоретические рассуждения? Поведение должно быть предсказуемым, и оно предсказуемо, исходя из определения операции +=.
Что, в каком-то ЯП x += n определено как x = n + x?

Аналогичный пост на хабре про ++i + ++i

А вот что говорит мой Сишный компилятор:
Warning[Pa079]: undefined behavior: variable «x» (declared at line 25) (or a value reached by some form of indirection through it) is modified more than once without an intervening sequence point in this D:\work\HabarHabar\main.c 26

Если я не ошибаюсь, то про это я читал еще в одной из первых своих книг Begin C# года так 2008. Да и не раз потом встречал про разницу между x++ и ++x.
Не увидел не чего не обычного и нового.

Выбрал 7 (для C), потом решил проверить:

20:33:19 {ruzin@MacBook-Ruzin}$~> cat z.c

#include <stdio.h>

int main() {
	int x = 3;
	x += x++;

	printf("%i\n", x);
	return 0;
}

(kit)20:32:54 {ruzin@MacBook-Ruzin}$~> cc z.c
(kit)20:32:58 {ruzin@MacBook-Ruzin}$~> ./a.out
7

=========
в С# не проверял.

Не пойму, почему x += n должно разворачиваться компилятором в x = x + n?

В ASM вроде есть добавления чего-то к чему-то уже существующему и сама операция += как раз сделана, чтобы минимизировать количество команд ASM.
=========

(kit)20:40:16 {ruzin@MacBook-Ruzin}$~> CFLAGS="-g -O0" make z
cc -g -O0 z.c -o z

(kit)20:40:49 {ruzin@MacBook-Ruzin}$~> gdb z
GNU gdb 6.3.50-20050815 (Apple version gdb-1822) (Sun Aug 5 03:00:42 UTC 2012)
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type «show copying» to see the conditions.
There is absolutely no warranty for GDB. Type «show warranty» for details.
This GDB was configured as «x86_64-apple-darwin»...Reading symbols for shared libraries… done

(gdb) break main
Breakpoint 1 at 0x100000f16: file z.c, line 4.
(gdb) run
Starting program: /Users/ruzin/z
Reading symbols for shared libraries +… done

Breakpoint 1, main () at z.c:4
4 int x = 3;

(gdb) disassemble

Dump of assembler code for function main:
0x0000000100000f00 <main+0>:	push   %rbp
0x0000000100000f01 <main+1>:	mov    %rsp,%rbp


0x0000000100000f04 <main+4>:	sub    $0x10,%rsp
0x0000000100000f08 <main+8>:	lea    0x5f(%rip),%rdi        # 0x100000f6e

0x0000000100000f0f <main+15>:	movl   $0x0,-0x4(%rbp)
0x0000000100000f16 <main+22>:	movl   $0x3,-0x8(%rbp)        # x = 3
0x0000000100000f1d <main+29>:	mov    -0x8(%rbp),%eax        # x (3) -> register EAX (3)
0x0000000100000f20 <main+32>:	mov    %eax,%ecx              # register EAX (3) -> register ECX (3)
0x0000000100000f22 <main+34>:	add    $0x1,%ecx              # register ECX (3) += 1 // register ECX (4)
0x0000000100000f28 <main+40>:	mov    %ecx,-0x8(%rbp)        # register ECX (4) -> x (4)
0x0000000100000f2b <main+43>:	mov    -0x8(%rbp),%ecx        # x (4) -> register ECX (4)
0x0000000100000f2e <main+46>:	add    %eax,%ecx              # register ECX (4) += register EAX (3) // register ECX (7)
0x0000000100000f30 <main+48>:	mov    %ecx,-0x8(%rbp)        # register ECX (7) -> x (7)
0x0000000100000f33 <main+51>:	mov    -0x8(%rbp),%esi
0x0000000100000f36 <main+54>:	mov    $0x0,%al
0x0000000100000f38 <main+56>:	callq  0x100000f4e <dyld_stub_printf>
0x0000000100000f3d <main+61>:	mov    $0x0,%ecx
0x0000000100000f42 <main+66>:	mov    %eax,-0xc(%rbp)
0x0000000100000f45 <main+69>:	mov    %ecx,%eax
0x0000000100000f47 <main+71>:	add    $0x10,%rsp
0x0000000100000f4b <main+75>:	pop    %rbp
0x0000000100000f4c <main+76>:	retq

End of assembler dump.
(gdb)

Все на много легче:

Рассмотрим еще раз код

int x = 3;
x = x + x++;

Теперь представим код вот так:


Так, если компилятор разбирает выражения слева на право, то первое что сделает компилятор, это посчитает левый узел сохранит его значение в переменную temp1, потом посчитает правый узел сохранит его значение в переменную temp2, а потом сложит

 int x = temp1 + temp2; 

Немного ликбеза:
Бинарные выражения большинством компиляторов/интерпретаторов выполняются так.
1) выбираем оператор с наименьшим приоритетом
2) вычисляем его слева-направо для всех операторов кроме присвоения.
вычисляем первый аргумент, вычисляем второй аргумент, выполняем первую операцию, вычисляем третий аргумент, выполняем вторую операцию и т.д.
Присвоение для понимания лучше преобразовать в выражение со скобками. Так a+=b раскрывается как a = (a+b).
a+=b=c+=d раскрывается так a = (a+(b=c+=d)), a = (a+(b=(c+=d))), a = (a+(b=(c=(c+d))))
Унарные операторы вычисляются когда вычисляется непосредственно аргумент в который они входят. Их можно раскрыть с помощью функции (х (в компиляторе используется инструкция дублирования значения на вершине стека)
Например:
x++;
T RightIncrement (ref T x) {
var tmpx = x;
x = x+1;
return tmpx;
}

++x; раскрывается как (x=x+1)

Тогда наше выражение раскрывается как
x = (x + RightIncrement(ref x))

Меня такой код совершенно с ума не сводит, очень простой. Но я бы не рекомендовал так писать. Вокруг очень много программистов, которые не знают язык, на котором пишут.

Как в Руби все запущенно… Даже варианта ответа такого нет.

$ irb
2.0.0-p247 :001 > x=3
 => 3 
2.0.0-p247 :002 > x += x++
2.0.0-p247 :003 >   x
 => 9