Take the 2-minute tour ×

In x = x + 1, is x evaluated twice? If so, does that mean in x += 1, x is only evaluated once? How are the two expressions evaluated in terms of compiler intermediate code?

For example, x++ could mean : take the location of x, load the contents of x into a register, and increment the value of x in memory.

Also I have read that x += 1 is useful when x is not a simple variable, but an expression involving an array. Any ideas why this is the case?

share|improve this question
This sounds like a lot of unfounded assumptions, in particular the title. I don’t see a reason why one should be more efficient than the other and I’m reasonably confident that it’s not the case on most C compilers. –  Konrad Rudolph Sep 19 '11 at 13:44
A compiler worth the money you paid for it will compile both expressions to the same object code. If you are worried about performance: measure, measure different code, different compilation flags, different resource usage, different everything. –  pmg Sep 19 '11 at 13:45
Do you know that x += 1 is more efficient than x = x + 1? Have you looked at the generated object code? –  Joe Sep 19 '11 at 13:45
How about finding some books that are not 17 years old? –  Svish Sep 19 '11 at 13:56
Asking about UDTs is a different question. This question is about C. –  David Heffernan Sep 19 '11 at 14:00

6 Answers 6

up vote 12 down vote accepted

In most compilers these would be identical

share|improve this answer
what about the older compilers? which do not optimize as much as the newer ones..why are they evaluated differently? –  user7 Sep 19 '11 at 13:52
If the compiler is inefficient, it may ignore the fact that x is referred to twice and load it and then perform the incrementing operation on the loaded value. –  Ofir Sep 19 '11 at 13:53
and what about the comment about arrays? –  user7 Sep 19 '11 at 13:56
again - a good compiler will be able to produce the same code, but an inefficient one might have more trouble with more complex expressions such as those involving array members –  Ofir Sep 19 '11 at 14:00

Just to give you a "real-world" example, consider this program:

int main()
    int i = 0;
    i += 1;
    i = i + 1;
    return 0;

Compiling it with GCC, in Darwin 11 with the following flags:

  • -S stop in assembler
  • -m32 to 32-bit platform, just to simplify things a bit

Will generate the following program, except for the comments and blank lines which I added. Take a look specially in the comments.

        .section        __TEXT,__text,regular,pure_instructions
        .globl  _main
        .align  4, 0x90
        pushl   %ebp              # cdecl function stuff
        movl    %esp, %ebp        #
        subl    $12, %esp         # get room for variables    
        movl    $0, -12(%ebp)     # i = 0;

        ; i += 1
        movl    -12(%ebp), %eax   # load i in register a
        addl    $1, %eax          # add 1 to register a
        movl    %eax, -12(%ebp)   # store it back in memory

        ; i++
        movl    -12(%ebp), %eax   #
        addl    $1, %eax          # just the same
        movl    %eax, -12(%ebp)   #

        ; i = i + 1
        movl    -12(%ebp), %eax   #
        addl    $1, %eax          # just the same
        movl    %eax, -12(%ebp)   #

        movl    $0, -8(%ebp)
        movl    -8(%ebp), %eax
        movl    %eax, -4(%ebp)
        movl    -4(%ebp), %eax
        addl    $12, %esp
        popl    %ebp

share|improve this answer

Why is x += 1 more efficient than x = x+1?

It isn't.

Why is x++ more efficient than x += 1?

It isn't.

The reason for preferring x += 1 to x = x+1 comes about when x is replaced with a much longer identifier, or perhaps a field in a class or struct. In that situation, the x += 1 version is more readable and even more importantly avoids the pitfalls of repeating yourself.

share|improve this answer

So there are already some questions that cover what you're asking here:

x=x+1 vs. x +=1

Incrementing: x++ vs x += 1

Which is faster? ++, += or x+1?

The bottom line is that in most but not all languages the compiler is going to make them identical anyway, so there's no difference in efficiency. The questions above go into a fair bit of detail on the subject.

share|improve this answer

With gcc, you can get the assembler code with gcc -S foo.c. I tried it with x += 1 and x = x + 1 and it was the same.

share|improve this answer

Because it takes 4 characters to write rather than 5.

This is the only way in which x+=1 is "more efficient" than x=x+1. However the += operator does have a few other advantages, like the fact that (x)+=1 works in macros where x is an expression that may have side effects which you want to avoid evaluating more than once...

share|improve this answer

Your Answer


