According to Scott Meyers, one thing where C++ shines over C is that function objects are faster than function pointers.
According to him, function objects are inlined, so there is an increase in speed.
I have two questions about this:
The C++ and C standards leaves a bunch of freedom to compilers. Compilers are free to count to 1 billion between every instruction, or only do so if an integer has a prime value in it.
Decent "real" compilers don't do this. This is a quality of implementation issue.
Inlining function objects into something like
std::sort is something that every real compiler does. It is exceedingly easy to detect what needs to be inlined in those cases, because the type information carries with it the code needed to be inlined.
Doing so with a function pointer is harder. Doing so with a function pointer where everything has been converted to
char* pointers is even harder.
The effect of this is that, in practice, a C-style call to
qsort vs a C++-style call to
std::sort can result in an large advantage for
qsort is roughly 2x slower than
std::sort, as shown here, in a ridiculously simple situation of sorting randomly arranged integers.
Inspecting the actual assembly code output is mainly a detail, and it is a lot of work for little return. Taking concrete real-world examples gives you an idea of how big the impact really is.
All 3 of clang, gcc and MSVC where able to make
std::sort be significantly faster than their
qsort. And as this is an easy optimization, while optimizing function pointers into inline calls is not, you'd expect less major compilers to be no better than this at