Do C & C++ compilers optimize comparisons with function calls?
c, c++, complexity-theory, optimization
Solution
Theoretically the possibility exists if `size()` was inlined, but to perform the optimization the compiler would have to
- Detect that you are testing specifically a "less than" condition
- Prove that the loop (assume one exists for the purposes of this discussion) results in a variable increasing monotonically
- Prove that there are no observable side effects from the loop body
That's a big bunch of things to count on IMHO, and it includes features which are not "obviously useful" in other contexts as well. Keep in mind that compiler vendors have limited resources so there has to be really good justification for implementing these prerequisites and having the compiler bring all the parts together to optimize this case.
Seeing as even if this is a perf issue for someone the problem can be easily solved in code, I don't feel that there would be such justification. So no, generally you should not expect cases like this to be optimized.
Problem
Do C and C++ compilers generally optimize comparisons with functions? For example, this page suggests that the `size` function on std::lists in C++ can have a linear complexity O(N) in some standard library implementations (which makes sense for a linked list). But in that case, if `myList` is a huge list, what would something like this do? ``` if (myList.size() < 5) return 1; else return 2; ``` Would the size() function find and count all N list members, or would it be optimized to short circuit after finding 5 members?