Switch Statement Oddities

Introduction

The grammar for the switch statement in C is simply:

switch ( expression ) statement

C++ inherited C’s switch and added the ability to add an optionalinit-statement, but that’s not central to this article.

Notice what’snotthere: there’s no mention of either case or default. Those are specified elsewhere in the grammar. This means the correctness of a switch statement is enforcedsemanticallyrather thansyntactically. The consequences of this are thatstatement:

1. Can beanystatement.
2. Is treatedexactly the sameas any other statement.
3. May also contain zero or more case labels and at most one default label.

Fall-Through

One of the controversial features of C is that, within a switch statement, cases “fall through” to the next case (if any). For example, given a value of 'a' for the variable c, code such as:

switch ( c ) { case 'a': printf( "apple\n" ); case 'b': printf( "banana\n" ); }

will print appleandbanana because after matching 'a' and printing apple, execution simply “falls through” into the 'b' case. This is an odd result of consequence #2 above since, outside of a switch, consecutive statements naturally “fall through” from one to the next. Inside of a switch between cases, this isn’t what you want most of the time, so you can use a break (or continue if inside a loop, return, or goto).

Most compilers will allow you to request to be warned when code falls through to a next case. As of C23 or C++17, you can include the [[fallthrough]] attribute to tell the compiler that a fall-through is intentional and not to warn you:

switch ( how_good ) { case VERY_GOOD: printf( "very " ); [[fallthrough]]; case GOOD: printf( "good\n" ); break; }

Perhaps the most famous example of where fall-through is useful is Duff’s device. You can read the details of it there, but the bottom line is that code such as (rewritten in modern C):

void send( short *to, short const *from, size_t count ) { size_t n = (count + 7) / 8; switch ( count % 8 ) { case 0: do { *to = *from++; case 7: *to = *from++; case 6: *to = *from++; case 5: *to = *from++; case 4: *to = *from++; case 3: *to = *from++; case 2: *to = *from++; case 1: *to = *from++; } while ( --n > 0 ); } }

is perfectly legal as a result of consequence #3, that is the fact that the do loop is inside a switch allowsanystatement to have a case label.

Single Statement

With switch, thestatementis invariably acompound-statement, that is a sequence of statements enclosed in {}, but it can alternatively be asinglestatement:

bool check_n_args( int n_args ) { switch ( n_args ) // no { here case 0: case 1: case 2: return true; // no } here fprintf( stderr, "error: args must be 0-2\n" ); return false; }

Since there is only the single statement of return true, the {} aren’t necessary just as they’d not be necessary after an if, do, else, for, or while either.

Aside from the fact that the above is an alternate way of writing:

if ( n_args >= 0 && n_args <= 2 ) return true;

(except that the expression is evaluated only once) there’s no legitimate reason for ever using a single statement with a switch, so I’d never recommend doing it. It’s just an odd result of consequence #1 above.

default Not Last

When a switch has a default, it’s invariably last, but it can actually be anywhere within the switch:

switch ( n_args ) { default: fprintf( stderr, "error: args must be 0-2\n" ); return false; case 0: // ...

In terms of performance, the position of default (or indeed the order of the cases) doesn’t matter. The only technical reason for not having default last would be if you wanted to have execution fall-through into the next case. Any other reason would be purely stylistic, e.g., you want to handle the common case first followed by special cases.

Statements Before the First Case

It’s also possible to have statementsbeforethe first case, for example:

switch ( n_args ) { printf( "never executed\n" ); case 0: // ...

Such statements areneverexecuted. Most compilers will warn about this. As far as I know, there’s no reason for ever having statements before the first case.

However, it’s marginally useful to havedeclarationsbefore the first case, for example:

switch ( n_args ) { int i; case 0: i = f(); // ... break; case 1: i = g(); // ... break; }

This is marginally useful when a variable is used only within the scope of the switch by one or more cases. Note that you shouldnotinitialize such variables like:

switch ( n_args ) { int i = 0; // WRONG: do _not_ initialize! // ...

because, even though the variable isdeclared, its initialization code isneverexecuted (just like the printf() in a previous example is never executed), so the code is deceptive. Instead, you must initialize such variables in each case that uses them.

Even though simple declarations (without initialization) are not executable code, some compilers will still (erroneously, IMHO) warn about them. Therefore, such declarations are not useful.

If you really want declarations only within the scope of a switch, you can either put them in the first case or only in the case(s) that use them. However, prior to C23, declarations immediately after a label are not allowed:

switch ( n_args ) { case 0: int i; // error (pre-C23) // ...

To work around that restriction, you can add {} for a case:

case 0: { int i; // OK now (all C versions) // ... }

A break-able Block

If you have a long block of code that you want to jump to the end of, there are a few ways to do it:

1. A sequence of if-else statements; or;
2. A sequence of if-goto statements; or;
3. A do { ... } while (0) statement with breaks.

Each has its trade-offs. Another way would be:

#define BLOCK switch (0) default: void f() { BLOCK { // ... if ( condition_1 ) break; // ... lots more code ... } // "break" above jumps here

Hence, it’s most similar to do { ... } while (0), but without having to put the while (0) at the end.

Conclusion

The apparent simplicity of the switch statement in C (and C++) is deceptive in that it allows several odd ways to write code using them, some useful, some not. The most useful is Duff’s device for loop unrolling.

The above is the detailed content of Switch Statement Oddities. For more information, please follow other related articles on the PHP Chinese website!