Advantages of switch - case over if else?

Answer 1

1.Switch statement looks a lot more tidy and easy to read and understand.

2.Here multiple statements need not to be enclosed within a pair of braces.

3.Switch statement executes faster than if_else because the switch statement checks the condition first and then jumps to the suitable case statement.

Answer 2

When code must branch we can either use an if statement or a switch statement. For a simple binary branch an if statement suffices, however for more complex branching a switch statement is usually preferred. The advantages of a switch statement can be summarised as follows:

1. Cleaner code

Switch statements are structured, resulting in cleaner code which is easier to both read and maintain, particularly with dense-case structures.

2. Performance

For dense cases, the compiler generates an efficient jump table from a single evaluation. For sparse case tables the compiler will either perform a binary search or will generate the equivalent if statement (what we refer to as a thinly-disguised switch statement). Thus the worst case performance of a switch statement is equivalent to that of an if statement, but is typically faster.

3. Precedence

The order of control expression in an if statement is important, typically capturing the most common case and working down to the least common. With a switch statement the order is less important, making it easier to add new cases without having to consider the precedence. However, see 5 below.

4. Default Case

The default case (if required) can be placed anywhere in a switch statement. With an if statement it must be placed last even if it is the most common case, which is inefficient.

5. Common Code

By omitting the break statement before the next case, execution will fall-through to the next case (the label is simply ignored), thus allowing two or more cases to be grouped together in order to execute code that is common to those cases. With an if statement, common code either has to be placed in a separate function (preferably one that can be inline expanded), duplicated in full (creating maintenance problems), or made accessible through a goto statement. A switch statement is effectively a procedural jump (using goto), so it makes no sense to avoid a procedural jump using a procedural jump.

Answer 3

There are no disadvantages as such since they are both designed for completely different purposes. An if statement can only evaluate true or false so if you wanted to emulate a switch statement using a series of if statements then you'd end up evaluating the same expression in every if statement until you encountered one that was true. Consider the following example:

void f (int i)

{

if (i==0) {/*...*/}

else if (i==1) {/*...*/}

else if (i==2) {/*...*/}

else if (i==3) {/*...*/}

else {/*...*/}

}

If you were to call f(3), you'd end up evaluating the following sequence of expressions:

3==0 (false)

3==1 (false)

3==2 (false)

3==3 (true)

That's 4 separate operations to reach the one piece of code you actually wanted to execute.

Now consider the switch version:

void g (int i)

{

switch (i)

{

case 0: {/*...*/}; break;

case 1: {/*...*/}; break;

case 2: {/*...*/}; break;

case 3: {/*...*/}; break;

default: {/*...*/};

}

}

If you call g(3), you perform one evaluation (returning the value 3) and automatically jump to case label 3. That is clearly more efficient than a series of if statements.

Conversely, if you had the following if statement:

void f (int i)

{

if (i&1) {/*...*/};

else {/*...*/}

}

It makes no sense to use a switch since there is only one evaluation to consider:

void g (int i)

{

switch (i&1)

{

case true: {/*...*/}; break;

default: {/*...*/}

}

}

The switch is really no less efficient than the if statement, but the if statement expresses the idea of a boolean expression more directly. The switch simply makes code slightly harder to read by obfuscating the logic.