++i 与 i++？ 为什么 i++ 更快，而 ++i 应该更快？

Question

++i is supposed to be faster than i++ right?? Then why this o/p?? Below is the code in CPP

start = clock();
srand(time(NULL));

cout<<"++i"<<endl;
for(int i=0;i!=-1;++i);

end = clock();
total_time = ((double) (end - start)) / CLOCKS_PER_SEC;
cout<<"Time taken for ++i : "<<total_time<<"\n\n";

start = clock();
srand(time(NULL));

cout<<"i++"<<endl;
for(int i=0;i!=-1;i++);

end = clock();
total_time = ((double) (end - start)) / CLOCKS_PER_SEC;
cout<<"Time taken for i++ : "<<total_time<<endl;

And this is the output

++i Time taken for ++i: 12.2812

i++ Time taken for i++: 12.125

Answer 1

Indeed conceptually at least ++i will never be slower than i++ due to the latter somehow storing the original value for later return.

But you are forgetting an important concept: the as-if rule. All modern compilers will optimise ++i and i++ to the same thing.

Note furthermore that a good compiler will optimise the undefined statement (due to int overflow) for(int i=0;i;=-1;++i); to a no-op. Many would also do so if i was an unsigned type. This is because its inclusion or otherwise has no effect on the program.

Answer 2

clock () method is not a good way to calculate the time difference

maybe you can use

high_resolution_clock::now()

Answer 3

If you want to understand why pre-increment should be faster, you must implement both and see the differences. This is how pre-increment would look like for a class that wraps an integer ( i_ ):

my_int_t& operator++()
{
  ++i_;
  return *this;
}

And this how the post-increment would look like:

my_int_t operator++( int )
{
  my_int_t r( *this );
  ++i_;
  return r;
}

Notice the different number of lines. More lines equals longer execution time IF the optimizations are turned off . If the optimizations are turned on, this might no longer be true - what you see is not what the compiler generates (although equivalent, most of the times).

See this demo for the expected result - notice #pragma GCC optimize ("O0") .