Switch optimization for many cases guarantees equal access time for any case? ( C++ )

I've seen answers here for specific languages, about switches with more than 5 cases being optimized with jump tables to guarantee constant access time for any case.

Is that so for C / C++?

Is it in particular for gcc? for visual studio?

If not, would sorting cases in order of occurrence fre开发者_开发问答quency help?

The standard doesn't guarantee anything about how the switch statement will be implemented. I've never seen a compiler produce a hash table, though quite a few will produce a jump table. Unless my memory is working even worse than usual, both VS and gcc can produce jump tables when the cases are sufficiently dense (for different values of "sufficiently"). Unfortunately, it's almost impossible to say (or necessarily even figure out) when sorting by frequency of occurrence will help -- it's different not only between compilers, but even between different versions of the same compiler.

For gcc's implementation see:

http://old.nabble.com/optimization-of-switch-statements-on-i386-to15366926.html#a15367662

• C and C++ guarantee nothing about the running time of switch statements.
• I'm afraid I don't know the implementation details for any compiler. It probably depends on optimisation flags.
• Sorting cases isn't guaranteed to help, again it's not specified by the standard, and your implementation may or may not:
  • Do different things according to compiler options
  • Document what it does
  • Guarantee not to change what it does in future versions
  • Completely ignore the order of cases in the source, and re-order them however it likes. Assuming of course the cases are "independent": no fall-through; no variable declarations starting in one case and spanning another case; no anything else I've forgotten.

This is what the compiler will do for you. In case of GCC it will use a jump table.

c (and by extension c++) only switches on integer types, so hashing is not necessary. The compiler will typically use an idiom appropriate to the architecture you're compiling for. This could be indexed addressing (if a small range is used), jump tables, or something entirely different.

A hash does not seem like an efficient way to implement a switch, because you will have extra cache misses due to the lookup.