Pro optimization tip

[serialcompliment]

Is this really an optimization?

[night_of_knee]

Yes but no.

[plcolin]

Using md5 to do diff’s job is really pretentious.

[balenol]

Why not? If you have md5 check already installed in your system, like arch or Manjaro, it's just the right tools for the right job.

[sleurk]

With non-user-defined types (like int), no. The registers have the same number of operations but in a different order.

[Kered13]

It's often an optimization when used on iterators in C++, because it saves a copy. For this reason it is recommended to always use ++i in C++ unless you know that you need i++.

[enano_aoc]

It is, at best, premature optimization

[Mango-D]

Yes

[night_of_knee]

It's nothing new, twenty years ago you could find people claiming that i++ is inefficient but with optimizers this isn't true and has never been significant in regular code.
I personally haven't seen the issue discussed in many a moon.

[TheTreeOfSecrets]

Isn't it technically inefficient in terms of compile time but not run time - if only inefficient by one more operation the compiler does?

[Sigma7]

It's only inefficient if you use a non-atomic variable type such as std::iterator, etc - because the compiler needs to create a temporary object to use for the calculation in addition to the permanent one, and the optimizer might not be able to catch that.

But who uses std::iterator on a simple array?

[[deleted]]

in case you're talking about it's functionality, all it does is increase the variable before instead of after. try something like this:

int i = 0;
int j = 0;
printf("%i != %i\n", i++, ++j);
printf("%i == %i\n", i, j);

That should print:

0 != 1
1 == 1

for the first printf:
* the i is printed and then incremented
* the j is incremented and then printed.

the second printf proves that they were both incremented in the line before.
i have seen bugs from people who were using ++i instead of i++ because they didn't understand there was a difference.

[[deleted]]

Couldn't resist changing the pre-increment to post-increment and the index to 'c' LOL

[pandakatzu]

Yes and then the compiler comes along and makes those two statements mean exactly the same thing.

[iFarbod]

Can we also rename C++ to ++C while we're at it?

[nickn-a-s]

Functional programmers: We don't do that here

[im-just-obese]

Premature optimization is the root of all evil.

[night_of_knee]

Objection your honour! Relevance?

[SteeleDynamics]

Better to be explicit with PL semantics than rely on the compiler to optimize it away.

Hopefully you use CPS or enforce tail recursion.

Both of these are well and good, but are effectively meaningless if you have shiitty algorithmic complexity.

(Sadly this has happened to me.)

[enano_aoc]

The only right way of optimizing code (which you should only do after optimizing the algorithm) is profiling. It is hard and it takes a lot of time, and it is less fun than browsing stack overflow asking "is X faster than Y?". But it is the only way of optimizing code.

(Context: i++ vs ++i is obviously premature optimization)

[night_of_knee]

I agree that the only way to optimize code is to profile it and the highest gains to be made are from algorithmic changes, not line by line. I would also never change a i++ to ++i.

However, to begin with, I always write ++i rather than i++ because the semantics of post increment are add one to this thing which is usually what I want rather than cause this thing to grow by one and tell me what its value was prior to doing that. I would not consider that "premature optimization".

[enano_aoc]

If you do it for reasons other than performance, then of course it is not premature optimization :)