Is there any difference in C and C++ between using if, else if, else if, ... and using switch () { case A: ... case B: ... } ?

Question

I am interested if there is any difference from the C or C++ compiler perspective whether I use:

if (value == a) {
    ...
}
else if (value == b) { 
    ...
}
else if (value == c) { 
    ...
}

versus

switch (value) {
    case a:
        ...
        break;
    case b:
        ...
        break;
    case c:
        ...
        break;
}

It feels to me that there is no difference, just syntactic. Does anyone know more about it?

Thanks, Boda Cydo.

Answer 1

A switch should be compiled to a jump with indirect addressing, while a sequence of if statements will be a chain of conditional jumps. First one is constant time; of course, you can put much more general conditions in an if.

Edit: I should mention that I wouldn't be surprised if some smart compilers are able to detect that all conditions in a chain of ifs have a particular simple form and convert to a switch. I don't know if they do, but you can always decompile and check.

Answer 2

Yes, there are differences. The cascaded ifs guarantee evaluation of the conditions in order. The switch guarantees only a single evaluation of whatever's used as the switch parameter. Depending on the compiler, the switch will often take (nearly) constant time regardless of the selected branch, whereas the if cascade pretty much guarantees that the first leg is the fastest, the second second fastest, and so on down to the last being slowest.

Answer 3

This is going to depend on how the compiler chooses to optimize your code. Code optimization for a compiler is a huge field.

To find the exact answer for your compiler determine how to build assembly code with it and look at the different assembly code that gets written to the file.

This was already done with one compiler and you can see the results here. http://www.eventhelix.com/RealtimeMantra/Basics/CToAssemblyTranslation3.htm

But the short short answers is yes. they will most likely be different.

Answer 4

There is a difference - with switch'es, the compiler may optimize the switch to use a lookup table. This may be possible if there are many values which are close enough to each other. For example, this switch:

switch ( integer ) {
  case 10:
     xxx
     break;
  case 12:
     yyy
     break;
  case 13
     zzz
     break;
}

could become (pseudocode):

address = lookup[ integer - 10 ]; // which is prefilled with { case_10, err, err, case_12, case 13 }
goto address;
case_10: xxx; goto err;
case_12: yyy; goto err;
case_13: zzz; 
err: //do nothing

Answer 5

The case statement may get compiled to a "jump table" which may be faster if there are dozens of cases and you execute this millions of times.

Answer 6

It's possible, if the select value is an integer (which it must be in C/C++), that the compiler could replace the if's with a jump table.

Answer 7

There are several differences, according to the Standard.

1. The value may be evaluated several times in the if chain, once in the switch statement. If evaluating value doesn't have side effects, this is unimportant.
2. The if chain will not allow fallthrough, while the switch statement will have fallthrough without the break.
3. The if chain allows general comparison, but the switch statement only allows comparisons to constant integral expressions.
4. The use of break; is different. It breaks out of the switch statement, but any further. If you need to break out of a loop or enclosing switch statement depending on a condition, you need the if chain.
5. Since a switch statement essentially does a goto to a case statement or default:, it will work in different places, the quintessential example being Duff's device. (IIRC, Tom Duff considered it a strong argument in the question of fallthrough, but he wasn't sure on which side.)

So, if value is evaluated without side effects, break; statements are used consistently and only in the switch, the comparison is to constant integral values, and it's not used in a funky way, the behavior can be identical. Whether any compilers will use this equivalency is another question.

Answer 8

+1 for David Thomley's answer, since I really find this the most complete.

One important thing is missing though, that is that case labels must be constant expressions that evaluate at compile time. With if both sides of the comparison (if you reduce the if statement to that) are evaluated at run time.