分配值时，char *指针上的C ++预增量与后增量

Question

so I get it that pre-increment is faster than post-increment as no copy of the value is made. But let's say I have this:

char * temp = "abc"; 
char c = 0; 

Now if I want to assign 'a' to c and increment temp so that it now points to 'b' I would do it like this :

c = *temp++; 

but pre-increment should be faster so i thought :

c = *temp; 
++temp;

but it turns out *temp++ is faster according to my measurements.

Now I don't quite get it why and how, so if someone is willing to enlighten me, please do.

Answer 1

First, pre-increment is only potentially faster for the reason you state. But for basic types like pointers, in practice that's not the case, because the compiler can generate optimized code. Ref. Is there a performance difference between i++ and ++i in C++? for more details.

Second, to a decent optimizing compiler, there's no difference between the two alternatives you mentioned. It's very likely the same exact machine code will be generated for both cases (unless you disabled optimizations).

To illustrate this : on my compiler, the following code is generated when optimizations are disabled :

# c = *temp++;
movq    temp(%rip), %rax
leaq    1(%rax), %rdx
movq    %rdx, temp(%rip)
movzbl  (%rax), %eax
movb    %al, c(%rip)

# c = *temp;
movq    temp(%rip), %rax
movzbl  (%rax), %eax
movb    %al, c(%rip)
# ++temp;
movq    temp(%rip), %rax
addq    $1, %rax
movq    %rax, temp(%rip)

Notice there's an additional movq instruction in the latter, which could account for slower run time.

When enabling optimizations however, this turns into :

# c = *temp++;
movq    temp(%rip), %rax
leaq    1(%rax), %rdx
movq    %rdx, temp(%rip)
movzbl  (%rax), %eax
movb    %al, c(%rip)

# c = *temp;
# ++temp;
movq    temp(%rip), %rax
movzbl  (%rax), %edx
addq    $1, %rax
movq    %rax, temp(%rip)
movb    %dl, c(%rip)

Other than a different order of the instructions, and the choice of using addq vs. leaq for the increment, there's no real difference between these two. If you do get (measurably) different performance between these two, then that's likely due to the specific cpu architecture (possibly a more optimal use of the pipeline eg.).