х = х + 1 против х + = 1

Question

У меня сложилось впечатление, что эти две команды приводят к одному и тому же концу, а именно увеличивают X на 1, но последнее, вероятно, более эффективно.

Если это не правильно, объясните разницу.

Если это правильно, почему последний должен быть более эффективным? Разве они не должны компилироваться в один и тот же IL?

Спасибо.

Answer 1

Стоит отметить, что + =, - =, * = и т. Д. Делают неявное приведение.

int i = 0;
i = i + 5.5; // doesn't compile.
i += 5.5; // compiles.

Answer 2

Я думал, что различия связаны с дополнительными тактовыми циклами, используемыми для ссылок на память, но я оказался не прав! сам не могу этого понять

instruction type        example                      cycles

=============================================== ====================

ADD reg,reg             add ax,bx                       1
ADD mem,reg             add total, cx                   3
ADD reg,mem             add cx,incr                     2
ADD reg,immed           add bx,6                        1
ADD mem,immed           add pointers[bx][si],6          3
ADD accum,immed         add ax,10                       1

INC reg                 inc bx                          1
INC mem                 inc vpage                       3

MOV reg,reg             mov bp,sp                       1
MOV mem,reg             mov array[di],bx                1
MOV reg,mem             mov bx,pointer                  1
MOV mem,immed           mov [bx],15                     1
MOV reg,immed           mov cx,256                      1
MOV mem,accum           mov total,ax                    1
MOV accum,mem           mov al,string                   1
MOV segreg,reg16        mov ds,ax                       2, 3
MOV segreg,mem16        mov es,psp                      2, 3
MOV reg16,segreg        mov ax,ds                       1
MOV mem16,segreg        mov stack_save,ss               1
MOV reg32,controlreg    mov eax,cr0                     22
                        mov eax,cr2                     12
                        mov eax,cr3                     21, 46
                        mov eax,cr4                     14
MOV controlreg,reg32    mov cr0,eax                     4
MOV reg32,debugreg      mov edx,dr0                     DR0-DR3,DR6,DR7=11;
                                                        DR4,DR5=12 
MOV debugreg,reg32      mov dr0,ecx                     DR0-DR3,DR6,DR7=11;
                                                        DR4,DR5=12 

Источник: http://turkish_rational.tripod.com/trdos/pentium.txt

инструкции могут быть переведены как:

;for i = i+1   ; cycles
mov  ax,   [i]  ; 1
add  ax,   1    ; 1
mov  [i],  ax   ; 1

;for i += 1
; dunno the syntax of instruction. it should be the pointers one :S     

;for i++
inc  i          ; 3
;or
mov  ax,   [i]  ; 1
inc  ax         ; 1
mov  [i],  ax   ; 1

;for ++i
mov  ax,   [i]  ; 1
;do  stuff      ; matters not
inc  ax         ; 1
mov  [i],  ax   ; 1

все оказывается одинаковым: S это просто некоторые данные, которые могут быть полезны. пожалуйста, прокомментируйте!

Answer 3

В C ++ это зависит от типа данных x и от того, как определяются операторы. Если x является экземпляром некоторого класса, вы можете получить совершенно разные результаты.

Или, может быть, вам следует исправить вопрос и указать, что x - это целое число или что-то еще.

Answer 4

Если x - простая целочисленная скалярная переменная, они должны быть одинаковыми.

Если x - это большое выражение, возможно с побочными эффектами, +=1 и ++ должны быть в два раза быстрее.

Многие люди концентрируются на такого рода низкоуровневой оптимизации, как будто именно в этом и заключается оптимизация. Я полагаю, вы знаете, что это гораздо более важный предмет.

Answer 5

Во время выполнения (по крайней мере, с PERL) нет никакой разницы. x + = 1 примерно на 0,5 секунды быстрее, чем x = x + 1, хотя

Answer 6

Еще в начале 1980-х годов одной из действительно классных оптимизаций компилятора Lattice C было то, что "x = x + 1;", "x + = 1;" и "х ++;" все производится точно такой же машинный код. Если бы они могли это сделать, компилятор, написанный в этом тысячелетии, определенно должен был бы это сделать.

Answer 7

Нет никакой разницы в программной эффективности; просто печатать эффективность.